Welcome to the Lounge

Re: Wordle 1,058 - 3 4 me

OriginalGriff8hrs 32mins ago

OriginalGriff

8hrs 32mins ago

Wordle 1,058 4/6*

⬜🟨🟨⬜🟨
⬜🟨⬜🟩🟩
🟩🟨⬜🟩🟩
🟩🟩🟩🟩🟩

"I have no idea what I did, but I'm taking full credit for it." - ThisOldTony
"Common sense is so rare these days, it should be classified as a super power" - Random T-shirt
AntiTwitter: @DalekDave is now a follower!

pkfox7hrs 41mins ago

pkfox

7hrs 41mins ago

⬜🟨⬜⬜🟨
⬜⬜🟨🟨⬜
🟩🟩🟩🟩🟩

In a closed society where everybody's guilty, the only crime is getting caught. In a world of thieves, the only final sin is stupidity. - Hunter S Thompson - RIP

Cp-Coder5hrs 52mins ago

Cp-Coder

5hrs 52mins ago

Wordle 1,058 4/6

⬛⬛🟨⬛⬛
⬛🟨⬛⬛⬛
🟩🟨⬛🟩🟩
🟩🟩🟩🟩🟩

Ok, I have had my coffee, so you can all come out now!

Sander Rossel3hrs 53mins ago

Sander Rossel

3hrs 53mins ago

Wordle 1,058 5/6

🟨🟩⬜⬜⬜
⬜🟩⬜⬜⬜
⬜⬜🟨⬜🟨
🟨🟩🟨🟨⬜
🟩🟩🟩🟩🟩

Best,
Sander

Azure DevOps Succinctly (free eBook)
Azure Serverless Succinctly (free eBook)
Migrating Apps to the Cloud with Azure
arrgh.js - Bringing LINQ to JavaScript

There are many gotos, but these ones are mine

Amarnath S1 hr 45mins ago

Amarnath S

1 hr 45mins ago

Wordle 1,058 6/6

⬜⬜⬜🟩🟨
⬜🟨🟨🟩⬜
⬜🟩🟨🟩🟨
⬜🟩🟩🟩🟩
⬜🟩🟩🟩🟩
🟩🟩🟩🟩🟩

honey the codewitch13hrs 2mins ago

honey the codewitch

13hrs 2mins ago

Gotos are frowned on. You should not use gotos. Long live gotos.

Until someone comes up with a better/faster/concise way of expressing the following DFA state machine (presented in part) I will continue to defend the use of gotos, even if their use cases have gotten significantly more narrow as progress has marched on.

When you need them, there is no better tool.

internal sealed partial class JsonStringRunner : FAStringRunner {
        private FAMatch NextMatchImpl(string s) {
            int ch;
            int len;
            int p;
            int l;
            int c;
            ch = -1;
            len = 0;
            if ((this.position == -1)) {
                this.position = 0;
            }
            p = this.position;
            l = this.line;
            c = this.column;
            this.Advance(s, ref ch, ref len, true);
            // q0:
            // [\t-\n\r ]
            if (((((ch >= 9) 
                        && (ch <= 10)) 
                        || (ch == 13)) 
                        || (ch == 32))) {
                this.Advance(s, ref ch, ref len, false);
                goto q1;
            }
            // [\"]
            if ((ch == 34)) {
                this.Advance(s, ref ch, ref len, false);
                goto q2;
            }
            // [,]
            if ((ch == 44)) {
                this.Advance(s, ref ch, ref len, false);
                goto q9;
            }
            // [\-]
            if ((ch == 45)) {
                this.Advance(s, ref ch, ref len, false);
                goto q10;
            }
            // [0]
            if ((ch == 48)) {
                this.Advance(s, ref ch, ref len, false);
                goto q11;
            }
            // [1-9]
            if (((ch >= 49) 
                        && (ch <= 57))) {
                this.Advance(s, ref ch, ref len, false);
                goto q17;
            }
            // [\:]
            if ((ch == 58)) {
                this.Advance(s, ref ch, ref len, false);
                goto q18;
            }
            // [\[]
            if ((ch == 91)) {
                this.Advance(s, ref ch, ref len, false);
                goto q19;
            }
            // [\]]
            if ((ch == 93)) {
                this.Advance(s, ref ch, ref len, false);
                goto q20;
            }
            // [f]
            if ((ch == 102)) {
                this.Advance(s, ref ch, ref len, false);
                goto q21;
            }
            // [n]
            if ((ch == 110)) {
                this.Advance(s, ref ch, ref len, false);
                goto q26;
            }
            // [t]
            if ((ch == 116)) {
                this.Advance(s, ref ch, ref len, false);
                goto q30;
            }
            // [\{]
            if ((ch == 123)) {
                this.Advance(s, ref ch, ref len, false);
                goto q32;
            }
            // [\}]
            if ((ch == 125)) {
                this.Advance(s, ref ch, ref len, false);
                goto q33;
            }
            goto errorout;
        q1:
            // [\t-\n\r ]
            if (((((ch >= 9) 
                        && (ch <= 10)) 
                        || (ch == 13)) 
                        || (ch == 32))) {
                this.Advance(s, ref ch, ref len, false);
                goto q1;
            }
            return FAMatch.Create(10, s.Substring(p, len), p, l, c);
        q2:
            // [\0-\t\v-!#-\[\]-\x10ffff]
            if ((((((ch >= 0) 
                        && (ch <= 9)) 
                        || ((ch >= 11) 
                        && (ch <= 33))) 
                        || ((ch >= 35) 
                        && (ch <= 91))) 
                        || ((ch >= 93) 
                        && (ch <= 1114111)))) {
                this.Advance(s, ref ch, ref len, false);
                goto q2;
            }
            // [\"]
            if ((ch == 34)) {
                this.Advance(s, ref ch, ref len, false);
                goto q3;
            }
            // [\\]
            if ((ch == 92)) {
                this.Advance(s, ref ch, ref len, false);
                goto q4;
            }
            goto errorout;
        q3:
            return FAMatch.Create(9, s.Substring(p, len), p, l, c);
        q4:
            // [\"\/\\bfnrt]
            if (((((((((ch == 34) 
                        || (ch == 47)) 
                        || (ch == 92)) 
                        || (ch == 98)) 
                        || (ch == 102)) 
                        || (ch == 110)) 
                        || (ch == 114)) 
                        || (ch == 116))) {
                this.Advance(s, ref ch, ref len, false);
                goto q2;
            }
            // [u]
            if ((ch == 117)) {
                this.Advance(s, ref ch, ref len, false);
                goto q5;
            }
            goto errorout;
        q5:
            // [0-9A-Fa-f]
            if (((((ch >= 48) 
                        && (ch <= 57)) 
                        || ((ch >= 65) 
                        && (ch <= 70))) 
                        || ((ch >= 97) 
                        && (ch <= 102)))) {
                this.Advance(s, ref ch, ref len, false);
                goto q6;
            }
            goto errorout;
        q6:
            // [0-9A-Fa-f]
            if (((((ch >= 48) 
                        && (ch <= 57)) 
                        || ((ch >= 65) 
                        && (ch <= 70))) 
                        || ((ch >= 97) 
                        && (ch <= 102)))) {
                this.Advance(s, ref ch, ref len, false);
                goto q7;
            }
            goto errorout;

Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix

Ravi Bhavnani12hrs 29mins ago

Ravi Bhavnani

12hrs 29mins ago

Most developers know goto statements are "bad" but very few know why or have even read Dijkstra's letter in CACM. And I'm willing to bet most developers haven't heard of the ACM. Frown | :(

goto statements that target entry into a block (as you could do in older versions of Fortran and Basic) are frowned upon because they make automated program verification impossible - aka "I can't say with certainty how you got here". Well behaved goto statements are not only fine, you couldn't write code without them.

To make it harder for novice programmers to misuse the goto statement, many languages such as C, C++, Java and C# (and many others) have created statements that implement well behaved goto's. They are:

break - goto the end of a switch or terminate the closest enclosing iteration statement
continue - start a new iteration of the closest enclosing iteration statement
return - exit the function in which it appears and return to the caller

And most (I suspect all) modern compilers won't allow specifying the target of a goto into another block. So use goto's, but use them the way nature intended. Smile | :)

/ravi

My new year resolution: 2048 x 1536
Home | Articles | My .NET bits | Freeware
ravib(at)ravib(dot)com

k505425mins ago

k5054

25mins ago

Ravi Bhavnani wrote:
And most (I suspect all) modern compilers won't allow specifying the target of a goto into another block

Not exactly sure what you mean here, but C/C++ certainly allows you to goto into a contained block, or to a label in another code block within the same containing block e.g.

void f(int n)
{
    if(n > 1)
      goto foo;
      // do stuff
     if( ... )
     {
        // some stuff
        if ( ... )
            goto foo;     // jumps down to inside next if block
        // other stuff
     } 
     if(  ... )
     {
       foo:
       // do more stuff
     }
}

Will compile just fine. You can get a warnings if you have an initialization before label foo, with the right warning options (gcc/clang, at least), but a quick perusal of the warning options doesn't seem to suggest that there's a warning for a goto int a contained block.

But maybe you meant that you can't jump from one block to another, like

C++

void foo()
{
   foo_label:
   // ...
}

void bar()
{
   // ...
   goto foo_label;  // invalid non-local goto
}

But for that you have setjmp/longjmp, which, of course, should be avoided like the plague.

"A little song, a little dance, a little seltzer down your pants"
Chuckles the clown

Amarnath S11hrs 23mins ago

Amarnath S

11hrs 23mins ago

One of my professors was the GOTO person for many of us students, in terms of resolving technical doubts and even giving career advice.

We need more such GOTOs, i feel.

trønderen10hrs 45mins ago

trønderen

10hrs 45mins ago

If I were given the responsibility for a state machine implementation like that, I would immediately run to my boss asking for permission to rewrite the whole thing as a table driven machine.

There is no way, with code like that, that I could guarantee that all inputs/events are properly handled in all cases (or given the proper error treatment). I would have to make a huge effort if I were to report a complete set of normal (non-error) ways to go from a given state to another, and which inputs/events would lead to which error states.

I've never written any CP article, but code like this makes my fingers itch to compose an article about proper table driven state machine implementation! Maybe I some day get around to do it Smile | :)

Religious freedom is the freedom to say that two plus two make five.

honey the codewitch10hrs 24mins ago

honey the codewitch

10hrs 24mins ago

Fair enough. I generated that code using Visual FA. It's slightly faster than the table driven variety, which Visual FA can also generate.

Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix

Site slowness

Chris Maunder21hrs 27mins ago

Chris Maunder

21hrs 27mins ago

We're running a heavy process that's causing some of our servers to creak a little. Sorry about any slowness you might experience today. It'll be over soon, I hope.

cheers
Chris Maunder

RickZeeland20hrs 5mins ago

RickZeeland

20hrs 5mins ago

No problem, I had to attend a funeral today $Shucks | :-\$
(no, not the funeral of the CodeProject website)

Chris Maunder19hrs 53mins ago

Chris Maunder

19hrs 53mins ago

Sorry to hear that, mate.

cheers
Chris Maunder

RickZeeland19hrs 19mins ago

RickZeeland

19hrs 19mins ago

Thanks Chris, it was my mothers funeral, everything went well, the weather was perfect, and I'm sure she would have appreciated all the kind words said by the four speakers. I concluded with some lines from an old poem:

Quote:
Farewell to thee, farewell to thee
Thou charming one who dwells in shaded bowers
One fond embrace ere I depart
Until we meet again.

BernardIE531718hrs 33mins ago

BernardIE5317

18hrs 33mins ago

I will do my part to alleviate the server burden by not posting this. Oops.

pkfox18hrs 2mins ago

pkfox

18hrs 2mins ago

Cheers Chris it wasn't slow for me - it was unavailable for hours

In a closed society where everybody's guilty, the only crime is getting caught. In a world of thieves, the only final sin is stupidity. - Hunter S Thompson - RIP

honey the codewitch16hrs 24mins ago

honey the codewitch

16hrs 24mins ago

I thought the server hamsters seemed a little haggard this morning.

Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix