Left as an exercise to the reader

http://abstrusegoose.com/474

Well, to be fair, if you know LC then writing a compiler for it is trivial. But yeah.

[deleted]

"Just an implementation issue"

It's perfectly cromulent advice.

Excellent! So the student won't know if the bug is in the script or in the compiler he wrote to compile it!

Yeah, I was wondering about that too. It didn't quite add up to me. That makes more sense though.

I believe you assemble assembly, not compile it.

Someone replied earlier with it: https://www.quora.com/Homework-Question-How-do-I-write-a-program-that-produces-the-following-output-1/answer/Sayantan-Khan

You could, but wouldn't it be better point-free?

putStr $ concat $ (=<<) (flip (++) ["\n"] . (flip take $ repeat "Smile!")) $ reverse [1..3]

Que?

Spanish Query Language Injection...nice.

Ugh... take your upvote and leave.

Still laughing. Bravo.

ja ja ja ja...

Was it that dirty ass t-sql

No... wait! Too late.

He already is.

Lim as GPA ->0 = business major

I tutored this kid a little during an intro course in college. He was horrific. Constantly falling asleep in class / tutoring sessions, not paying attention, etc.

This kid literally played Motobike flash games every. Single. Class. Like.. I don't know how the hell anyone can play a game so simple for that damn long. Anyway, last I heard, he switched his major to theater arts.

*Project Manager

A mediocre villain, maybe-- definitely not super.

Well, really, I just filed a 100 pages solution for a problem I was assigned at school, containing solutions in 42 programming languages including Brainfuck and Whitespace - can I earn at least $675,000 a year by passing Google's technical interview?

We ain't doing your statistics homework!

Depends on how fast you can generate random numbers... It's 38 characters total, and you need to randomly generate approximately 2³¹ characters before you get one. log2 38 is about 5.25. So you need to generate and check 2^36.25 characters. If you can generate and check 100,000 per second, it should take around 9 days. If you can only generate and check 10K per second, it'll be closer to 3 months.

Showing my work: https://www.google.com/search?q=2%5E36.25+s+to+years&oq=2%5E36.25+s+to+years&aqs=chrome..69i57.2696j0j1&sourceid=chrome&ie=UTF-8#q=(2%5E36.25%2F100000)+seconds+to+days

[deleted]

If I parallelize it, 3 minutes 23 seconds on my 5820K at 4.5 GHz. The single-threaded original solution took 11m46s.

https://gist.github.com/domyd/5ede8144de4f08aaa1c069918c7eed2b

I'd be happy to know of ways to make this faster :)

Edit: Compiled with VS 2015 Update 3 and .NET Framework 4.5.2, Release Build.

Compiles immediately, seems to take a while to run though. Sadly online compilers won't give me an answer : Compilation time: 0,14 sec, absolute running time: 5,03 sec, cpu time: 5,02 sec, average memory usage: 22 Mb, average nr of threads: 5 I did get the S though..

Technically I think it's O(n).

None or all and everything between.

Not at all. Bogosort requires you to get extremely lucky by hitting ALL the characters correctly at once.

In this program, you only need to get lucky on the next character that's being printed.

Big O time would be infinite, because Big O is worst-case and in theory it might never generate the numbers you need. Best-case scenario is n tries, though!

Deep cut on the bogosort.

Exactly my thought, ‘No bootable device’.

Thanks. I've edited there.

UEFI doesn't load boot sectors, and it's not guaranteed to give you a VGA framebuffer at that address either.

KTHXBYE

Those solutions are much shorter than I would've expected them to be. Nice work!

What's the equivalent of segfault - SAD PANDA?

TDD for proper design, of course.

[deleted]

"Reverting the revert commit, since it clearly did not revert as intended"

Love it.

Writing FizzBuzz by hand is for losers, I prefer neural network.

i lol'd when i opened up the factories folder. that's just amazing right there.

hahah needs to support deep learning

As an enterprise Java developer, it made me laugh and then cry.

Honest question - what are your biggest grievances about enterprise Java ?  

I am a full stack Java developer (Struts .. boo .. I know) and honestly, I don't see any particular advantage / disadvantage with any modern frameworks (.Net, Ruby, PHP, Java etc). One is a good as the other.  

The biggest difference is the developers mastery of a particular framework.

SFW version: "and show it to your boss".

I decided to try and contribute, but since I don't have the stupid minimum reputation I can't do anything except try and answer questions in the 15 seconds before someone else gives a better answer.

dumb question, but what should I use instead of array list in .net then? It's basically what I've been taught to use.

Might be a dumb question, but I wonder, how do you actually get to the point where you know those things? I follow different tech news site, but I feel like I'm not following the right things. Where should I keep myself up to date for a given language? I guess the release notes is a good start, but it feels I'm always behind the curve.

*And when I find documentation, I often learn later on that it was actually legacy stuff.

oh oh. just implemented background workers in an app. Stand by. googling alternatives.

I've seen lots of answers which use legacy (1.1. or 2.0) techniques to solve modern issues. Like people suggesting you should use ArrayList or BackgroundWorker in 4.0+ code.

Languages evolve and it saddens me when people are quick to resound with answers that are already outdated.

As a .NET dev, I fully understand where you're coming from on this, but even with shiny new ways to do something, sometimes the old tricks are perfectly acceptable answers in that they work exactly the way they were designed.

To specifically take BackgroundWorker as an example, I saw an SO post where someone was asking how to process a task in the background of a WinForms application and update a status bar with progress. WinForms is not exactly hot new stuff, right? The top answer, before the question was closed and buried, was how to use async/await to write a routine that did the processing work and how to hook the response into events that trigger a redraw, thus updating the UI for the user....this is for Win-freaking-Forms! BGWorker was practically designed for this purpose!

As someone who programs in .net for a Windows CE platform with .net 2.0, I love those people with all my heart.

It's the poor effort that most people fail to put in. Non of us would have made it as programmers if we couldn't work out simple loops. Some people just want ze codez and don't care how it works.

I think in a lot of cases, being simple would make it the best answer.

Sure, but sometimes you only need a simple solution, or one that will work on most configurations. The "correct" simply might not be appropriate for a beginner, or easy to explain, or... there's any number of reasons that you might use something that's not longer standard but still a core part of the language.

Whoa whoa whoa, why the fuck should I not use array list?

I used to contribute a lot on SO with .NET. Got tired of "okay, to do this the current best practice it..." (writes like five lines of code explaining in detail what each line does) Then the one that is accepted is open nuget, add package "NoSeriouslyDontUseThis" and it's 12 dependencies, convert object to json, use package's non descriptive "process" method, convert results back to your object, wrap in a try catch, if catch then throw... eye spasms

Seems like every reasonable question gets the proper way to fix something as second or third response, decent upvotes, but some atrocity that should never again be spoken of takes the lead, once it gets that green check it surges to the top, even in cases where it doesn't actually even work... (all that said, I still hop on SO on occasion, but I don't respond to much anymore unless something is particularly interesting to me.)

To be fair, there are a ton of XY problems out there. There's a reason StackOverflow's canonical answer to using regex to parse HTML is what it is.

Maybe people are sometimes a little over-zealous, but sometimes there isn't actually a good answer to "Why would you want to do that?"

A lot of my answer which was you should do instead received good reception.

In particular the famous one: how can I have dynamic name for variable in python ?

I think it is fair to warn people of their terrible decisions, but also answer the question. Otherwise you are not helping at all.

It's luck of the draw. One time, a few years ago, I have a mysterious issue where a particular COM Add-In I was tasked with making. It would reliably, without fail, cause me to BSOD when I used a certain function of it. I was having enormous trouble trying to figure out on my own wtf was causing it. I turn to SO...

All I get is "That is not possible; you can't BSOD in modern version of windows from usercode." and things liek that. Well that's not true asshole, because I am and it is happening reliably! Why would I have even asked the question if it was not happening?

In the end, it the issue resovled itself afterI got desperate and ran some windows updates. Who knows what the hell it updated, but whatever it was fixed the issue. The point though is that instead of seeing the question and just moving along, people wasted their time telling me that it is not possible.

Nobody can read perl except the author of that particular piece of code and that only last until next week, regardless of rigorousness of the comments.

Hm. Yes, shouldn't be too hard. The machine code part on the first line has six spaces, which - if I understand Whitespace correctly - should do nothing worse than push the number 4 onto the stack. Whitespace programs can exit prematurely, so it can all fit into the part before the next preprocessor statement, without fear of unwanted statements in the rest of the file.

It is three things; C code, PowerShell script, and a .COM DOS executable. Just rename file as needed.

That's not obfuscated...

Perl is amazing! It's just other people's Perl that sucks.

IT WAS ALL WE HAD FOR CGI! Well not all we had for CGI but it was common on commercial Unix machines running the web early on. Servers didn't tend to have compilers installed so you couldn't write CGI programs in C or Fortran. No (few?) commercial Unixes shipped Python by default and PHP wasn't a thing yet. This left Perl, bash, and TCL for CGI on most machines.

Perl was already popular as a glue language so when it came to putting programs on the web via CGI Perl was an obvious choice. It could do all the same gluing as on workstations but spit HTML to stdout.

And that day was sometime in 1998.

It would have been really funny to turn in a homework assignment in malbolge. I wanted to, but we never really got anything as simple as this to start with.

It has more to do with bases and bit operations than perl per se - but still kudos to /u/vsTerminus for taking the time and the trouble to break it down so nicely.

IF ANYONE WANTS AN EXPLANATION FOR THE PERL CODE, YOU HAVE TO PROMISE NOT TO CRUCIFY ME FOR USING INCORRECT TERMINOLOGY OR POOR COMPARISONS TO EXPLAIN CONCEPTS. THIS IS INTENTIONALLY OVERSIMPLIFIED, AND YET STILL ASSUMES YOU HAVE SOME BASELINE KNOWLEDGE IN BASES (BINARY, HEXADECIMAL, OCTAL, DECIMAL) AND BITWISE OPERATIONS.

FEEL FREE TO CORRECT ANYTHING I AM MISTAKEN ABOUT, BUT DO REMEMBER THAT IT IS OVERSIMPLIFIED ON PURPOSE.

HERE'S THE RAW ANSWER:

#!/USR/BIN/PERL

$HELL = SUB { $O=""; FOREACH(@{$[0]}) { $O .= CHR($); } RETURN $O; };

$Z = 0B100;

$X = [0123];

$X->[1] = 0X6D;

$X->[2] = $$X[1] & ~$Z;

PUSH @$X, @$X[1,2];

$Y = \$$X[$Z];

$X->[0B11]--;

$$Y -= $Z;

$X->[05] = (666>>$Z)-($Z<<1);

WHILE(--$Z) { FOR(1..$Z) { PRINT $HELL->($X); } PRINT $/; }

AND HERE IT IS WITH A FEW NEWLINES ADDED, AND A FEW VERY BASIC COMMENTS

#!/USR/BIN/PERL

# THIS FUNCTION BUILDS THE "SMILE!" STRING AND RETURNS IT TO THE CALLER.

$HELL = SUB

{

$O="";

FOREACH(@{$_[0]})

{

$O .= CHR($_);

}

RETURN $O;

};

# THIS BLOCK BUILDS AN ARRAYREF CONTAINING THE ASCII DECIMAL VALUES FOR THE PHRASE "SMILE!"

$Z = 0B100;

$X = [0123];

$X->[1] = 0X6D;

$X->[2] = $$X[1] & ~$Z;

PUSH @$X, @$X[1,2];

$Y = \$$X[$Z];

$X->[0B11]--;

$$Y -= $Z;

$X->[05] = (666>>$Z)-($Z<<1);

# THIS LOOP IS RESPONSIBLE FOR CALLING THE FUNCTION AT THE TOP THE CORRECT NUMBER OF TIMES PER LINE

# AND FOR THE CORRECT NUMBER OF LINES.

WHILE(--$Z)

{

FOR(1..$Z)

{

PRINT $HELL->($X);

}

PRINT $/;

}

NOW LET'S GO THROUGH AND EXPLAIN IT.

#!/USR/BIN/PERL

# THIS IS A SUBROUTINE. WHILE IT DOESN'T SPECIFICALLY PRINT "SMILE!" AND ONLY "SMILE!",

# IT CAN BE USED TO ACCOMPLISH THIS GOAL.

# THE SUBROUTINE ITSELF SIMPLY ACCEPTS AN ARRAY OF CHARACTERS AND CONCATENATES THEM INTO A SINGLE STRING

# VARIABLE, WHICH IT THEN RETURNS TO THE CALLER.

$HELL = SUB

{

$O=""; # START WITH AN EMPTY STRING

# FOREACH CHARACTER IN THE ARRAY

# $_ IS A SPECIAL VARIABLE THAT REFERS TO A DEFAULT ARGUMENT OR SEARCH SPACE.

# IT CAN BE USED ALL OVER THE PLACE, BUT HERE IT REFERS TO AN ARRAY OF ARGUMENTS PASSED INTO THE FUNCTION.

# $_[0] IS THE FIRST ARGUMENT, WHICH WILL BE AN ARRAY REF CONTAINING 6 ELEMENTS. MORE ON THAT LATER.

# @{ $_[0] } ALLOWS US TO TREAT THE REFERENCE AS AN ARRAY SO IT CAN BE GIVEN TO

# THE FOREACH LOOP TO PROCESS ONE AT A TIME.

FOREACH ( @{ $_[0] } )

{

# THE CHR FUNCTION TAKES A NUMERICAL VALUE AND RETURNS THE EQUIVALENT CHARACTER.

# THIS CHARACTER IS APPENDED TO $O

$O .= CHR( $_ );

}

# ONCE ALL NUMBERS WITHIN THE ARRAY REF HAVE BEEN CONVERTED TO CHARACTERS AND

# APPENDED TO THE $O STRING, RETURN IT TO THE CALLER.

RETURN $O;

};

# THE SAME WAY YOU WOULD WRITE "0X____" TO DENOTE HEXADECIMAL, YOU CAN USE

# "0B____" TO DENOTE BINARY. 100 IN BINARY IS 4 IN DECIMAL.

# THIS ESSENTIALLY READS $Z = 4, AND IS OUR LOOP COUNTER, CONTROLLING HOW MANY LINES OF SMILES WE PRINT.

$Z = 0B100;

# $X IS INITIALLY DEFINED AS AN ARRAY REFERENCE CONTAINING ONLY THE VALUE 0123 IN POSITION ZERO

# FOR YOU C DEVS, IT'S KIND OF LIKE USING A POINTER.

# THE INTERESTING THING ABOUT 0123 IS THAT THE LEADING ZERO DENOTES THAT THIS IS IN OCTAL. OCT 123 = DEC 83

# SO OUR INITIAL ARRAY CONTAINS: [83]

$X = [0123];

# THE NEXT LINE DEFINES POSITION ONE OF THE ARRAY TO BE 0X6D

# 6D IN HEX IS 109 IN DECIMAL

# THE -> IS NECESSARY TO DEREFENCE THE ARRAY REFERENCE, JUST LIKE A C POINTER.

$X->[1] = 0X6D;

# THIS LINE DEFINES THE THIRD VALUE OF THE ARRAY (IN POSITION 2)

# $$X[1] IS A "SIMPLE SCALAR CONTAINING A REFERENCE", AND IS AN ALTERNATIVE WAY

# TO GET AT THE ARRAY ELEMENTS INSTEAD OF USING THE -> TO DEREFERENCE.

# UNARY "~" PERFORMS BITWISE NEGATION, THAT IS, 1'S COMPLEMENT.

# THE 1'S COMPLEMENT OF A BINARY NUMBER IS DEFINED AS THE VALUE OBTAINED

# BY INVERTING ALL THE BITS IN THE BINARY REPRESENTATION OF THE NUMBER (SWAPPING 0S FOR 1S AND VICE VERSA).

# IN THIS CASE, $$X[1] IS 0X6D OR 0B01101101 AND $Z IS 0B100 (4 IN DECIMAL)

# ~$Z (1'S COMPLEMENT) IS 0B011, EXCEPT BECAUSE CHARACTERS ARE 32 BITS AND

# THE OTHER 29 WERE ZEROES BEFORE, THEY ARE ONES NOW.

# THAT GIVES US 11111111111111111111111111111011, OR 4294967291 IN DECIMAL.

# SO NOW WE'RE DOING A BITWISE "AND" OPERATION ON THOSE TWO BINARY VALUES,

# MEANING ONLY POSITIONS WHERE BOTH NUMBERS CONTAIN A 1 REMAIN A 1, THE REST BECOME ZERO.

# 00000000000000000000000001101101

# & 11111111111111111111111111111011

# = 00000000000000000000000001101001

# AKA, 105 IN DECIMAL

$X->[2] = $$X[1] & ~$Z;

# SO NOW OUR ARRAY WITHIN $X CONTAINS: [83, 109, 105]

# THIS NEXT LINE JUST TAKES POSITIONS 1 AND 2 (109 AND 105) AND ADDS THEM TO THE END OF THE ARRAY,

# LEAVING US WITH [83, 109, 105, 109, 105]

# @$X IS JUST LIKE $$X[1] ABOVE, EXCEPT WE NEED TO ACCESS THE REFERENCE AS IF IT WERE AN ARRAY,

# NOT A SCALAR THIS TIME.

PUSH @$X, @$X[1,2];

# $Y IS ACCESSING POSITION 4 (REMEMBER $Z = 4) OF OUR ARRAY, BUT RATHER THAN COPYING THE VALUE,

# THE \ DENOTES A REFERENCE TO THE ACTUAL VARIABLE IN MEMORY.

# IN ESSENCE, CHANGING $Y CHANGES POSITION 4 OF OUR ARRAY (WHICH CURRENTLY CONTAINS THE VALUE 105)

$Y = \$$X[$Z];

# 0B11 IS 11 IN BINARY OR 3 IN DECIMAL.

# WE'RE SUBTRACTING 1 FROM THE VALUE IN POSITION 3 OF THE ARRAY (FROM 109 TO 108)

$X->[0B11]--;

# NOW WE'RE SUBTRACTING THE VALUE OF $Z (4) FROM $$Y, WHICH ALSO SUBTRACTS 4 FROM

# WHATEVER IS IN POSITION 4 OF THE ARRAY (FROM 105 TO 101)

$$Y -= $Z;

# THE ARRAY NOW LOOKS LIKE: [83, 109, 105, 108, 101]

# FINALLY, WE'RE GOING TO ADD A 6TH ELEMENT TO THE ARRAY ( IN POSITION 5 )

# >> AND << ARE BITWISE OPERATORS THAT SHIFT ALL OF THE BITS OVER BY ONE POSITION LEFT OR RIGHT.

# 666 IN DECIMAL IS 0000001010011010 AND WE ARE SHIFTING IT TO THE RIGHT BY $Z (4) PLACES, LEAVING US WITH

# 0000000000101001 OR 41

# NEXT, $Z IS 4, OR 0100 IN BINARY.

# SHIFT THAT ONE PLACE TO THE LEFT AND WE GET 1000 OR 8 IN DECIMAL.

# THE STATEMENT NOW READS 41 - 8, SO OUR 6TH ELEMENT IN THE ARRAY IS GOING TO BE 33.

$X->[05] = (666>>$Z)-($Z<<1);

# THE ARRAY IS NOW [83, 109, 105, 108, 101, 33]

# IF YOU HAVEN'T FIGURED IT OUT YET, TAKE A LOOK AT AN ASCII TABLE ON GOOGLE.

# CONVERT THE DECIMAL VALUES IN OUR ARRAY TO THE CHARACTERS THEY REPRESENT.

# 83 = S

# 109 = M

# 105 = I

# 108 = L

# 101 = E

# 33 = !

# SO ALL WE DID WAS USE SOME DIFFERENT BASES (BINARY, HEX, OCTAL, AND DECIMAL) AND SOME

# BITWISE OPERATIONS TO BUILD AN ARRAY OF CHARACTERS THAT SPELL OUT "SMILE!"

# THIS IS THE MAIN LOOP.

# WE WILL START BY DECREMENTING $Z AND THEN CHECK THAT IT IS STILL > 0.

# SINCE $Z = 4, BUT WE'RE GOING TO DECREMENT IT TO 3 BEFORE CHECKING, WE WILL PRINT LINES AT

# VALUES 3, 2, AND 1 BEFORE STOPPING.

WHILE(--$Z)

{

# THIS CONTROLS HOW MANY TIMES WE PRINT "SMILE!" ON A LINE.

# WE COUNT FROM 1 TO $Z, BUT SINCE $Z IS DECREASING WITH EACH ITERATION OF THE LOOP,

# WE WILL PRINT ONE LESS SMILE! EACH TIME.

# FIRST LINE 1, 2, 3

# SECOND LINE 1, 2

# THIRD LINE 1

FOR(1..$Z)

{

# NOW WE CALL THE $HELL SUBROUTINE FROM THE TOP OF THE PROGRAM, WHICH

# BUILDS A STRING OUT OF OUR ARRAY AND RETURNS IT TO THE PRINT FUNCTION.

# EFFECTIVE IT PRINTS "SMILE!"

PRINT $HELL->($X);

}

# $/ IS THE INPUT RECORD SEPARATOR; NEWLINE BY DEFAULT. AKA, PRINT A NEWLINE (\N)

PRINT $/;

}

---

^{I am a bot, and I don't respond to myself.}

Untyped Lambda Calculus. The thing doesn't have any data types so you build up everything from functions.

Here's the same kind of stuff a bit more readable in Haskell, and with type signatures:

pair :: a -> b -> (a -> b -> c) -> c
pair x y f = f x y

myPair :: (String -> Char -> t) -> t
myPair = pair "string" 'c'

left :: ((a -> b -> a) -> c) -> c
left p = p (\x y -> x)

Take a piece of paper, write down left myPair, expand the definitions, apply the reduction rules, and you end up with "string".

Of course, writing Z as above won't work in Haskell (because types) but you can use fix, instead.

If the syntax itself is throwing you, that's because it's full of Fat-arrow lambdas -- a wonderfully compact bit of syntax that's now supported in Firefox and Chrome, but not Safari or IE so you can't really depend on it.

You're not wrong (and I have other projects that are more unique). The guessing game has a number of features that allow me to put a lot of interesting material into one project, which is probably why a lot of teachers use it as a project.

For starters, everyone understands the premise, and there's a number of ways to implement it. My students are just getting the hang of looping when we do it, so we can talk using a for loop vs while loop (and when each approach is better). There's an extended if/else ladder that some students find challenging. We can talk about break and continue, and using boolean flags to "remember" if the player won or not. It's a game, and every 15-year-old boy that walks into my classroom has dreams of being a game developer. Being a game, we use random number generation in a meaningful way, and talk about how random number generation is important in a lot of different types of games.

We can also talk about game strategy, and (if we're limiting guesses) how many guesses to allow the player to make the game challenging. Working through that math gives some students their first introduction to logarithms, which I bring back when we analyze different kinds of sorts.

If you can think of another project that checks so many different topical boxes, I'm all ears! :)

You're not wrong! I don't mind open-ended questions, but they require exponentially time and creativity in all points of the assignment. It's very difficult to come up with these things all by yourself, much less design, administer, and grade the assignment.

I'm actually lobbying to bring in a STEM-oriented program that include a lot of open-ended curricula like this, but it would require a decent chunk of cash to bring into the school, and another cash infusion to hire someone to teach the straight math courses that I also teach.

Very easy to find when scrolling through the thread: Just wait until the browser stops for a couple seconds and the scrollbar jumps up by a third or so.

This is justification for a compiler optimiser that looks at your code and just says "no".

It is a demonstration of a combinator-based obfuscation technique which is even more cryptic than the VM-based approaches. By not using machine level control flow, data structures and arithmetics you can encode, say, a crucial part of an algorithm that you do not want to be reverse engineered.

It is trivial to generate such a code from an untyped lambda calculus (see it in some other answers here), but a reverse transform is much harder.

An algorithm described in detail in A. J. Field, P. G. Harrison, "Functional programming" (1)

See the implementation in Racket here (2)

(1) https://books.google.co.uk/books/about/Functional_Programming.html?id=nYtQAAAAMAAJ

(2) http://pastebin.com/KuBpJEtR

Could not find the version I used to build this example, so here is an older Racket implementation. The payload contained implementations for the Church numerals, Church pairs, etc., see a detailed explanation here:

https://en.wikipedia.org/wiki/Church_encoding

While Eclipse is restarting or butchering your workbook, install IntelliJ.

LOL CODE

So you have a compiler for everything...Awesome.

This is how you get the asker shot by his teacher.

You're right, printf takes TextFormatWriter<T>. F# is not my mother tongue. Updated code:

let f = for c in [| 083; 109; 105; 108; 101; 033 |] do printf "%c" (char c)

There is not implicit conversion for strings either, so it becomes a tidbit more verbose.

It won't because there's no format string

Additionally it's an array so you couldn't print it as a string anyway without an intermediate to turn it into a string

Unless there's a format specifier to take 'a [] and turn it into string

This is mine.

Yes it is. There was an article about someone who was asked in an interview to do something very simple and replied with "can I use TensorFlow?" very amusing, I thought. If we're going with roundabout ways to get a certain function, I think ML is a beautiful way to convolute things.

Someone later said "I'm sure there's a more compact solution, but I don't think I hate myself as much as the guy who offered the Brainfuck solution"

its been done! Malbolge.

Piet, a fun esoteric programming language. I wasn't trying to do penis drawings, but if that's what they look like, it's a happy mistake.

Who says he isn't taking initiative? I'd say that knowing when to ask for help is definitely initiative.

Many colleges don't let you drop after the first few classes without a penalty. And who says he hasn't tried asking his professor? An intro to computer science class is likely to have tons of students asking for help, and many professors just aren't accommodating.

It seems like if the professor won't help, your peers are just as lost as you, and you need the course credit, then your best option is to ask the internet.

It was a real kid with a real question that he didn't bother thinking about for as much time as it took to type the question out.

You surely meant "quora users", not "programming community"? Those snippets are witless and boring.

function f(x,y){if(y>=0){setImmediate(f,x,--y);}process.stdout.write(y>=0?x:"\n");return x;}f(f(f("smile",3),2),1);

It's clearly async because the return value is somewhere in the middle

Twas a jest, but I believe it wasn't very good.