Today, I learned the shortest command which will determine if a ping from your machine can reach the Internet:

ping 1.1

This parses as 1.0.0.1, which thanks to Cloudflare, is now the IP address of an Internet-facing machine which responds to ICMP pings.

Oh, you can also use this trick to parse 10.0.0.x from `10.x` or 127.0.0.1 from `127.1`. It's just like IPv6's :: notation, except less explicit.

Me: Optimize a sort & match method in backend because users complain it's a bit slow.

Coworker: These algorithms are both O(n), so they're identical *closes PR*

Me: *start zoom call* "Heeeeeeeeeey Iiiiiiiiiii wouuuuuuuld liiiiiiiiike toooooo diiiiiisscuuuuus thaaaaaaaat puuuuuuulllll reeeeeequuuueeest yooooouuuuu cloooooossseeeed"

Coworker: "wtf are you doing, why are you talking so slow"

Me: "No matter whether I talk fast or slow, the information still reaches you in O(n) time, so why are you complaining"

I fucking hate it when people misunderstand the purpose of (or abuse) big O notation. It's an estimate of how an algorithm SCALES once the set increases in size, in which case you leave out both less significant terms and constant factors.

But those terms and factors are important when you're talking about the DIRECT PERFORMANCE of the algorithm on fixed-size sets, instead of SCALING to larger sets.

1n and 10n are both O(n), but 10x performance on a job that used to take 10 minutes is still significant.

Writing more infrastructure than product.

Look, my application requests and transforms data from a single external API endpoint, it's just one GET request...

But I made an intelligent response caching middleware to prevent downtime when the parent API goes down, I made mocks and tests for everything, the documentation is directly generated from the code and automatically hosted for every git branch using hooks, responses are translated into JSONschema notation which automatically generate integration tests on commit, and the transformations are set up as a modular collection of composable higher order lenses!

Boss: Please use less amphetamine.

The new O notation

When I learnt programming, sugar was still made out of salt and hence not used in coffee.

Also, we didn't have source level debuggers, only the "print" method. However, compiling was also slow. It was faster and more convenient to go through the program and execute the statements in one's head. This helped understanding what code is doing just by reading it. It also kept people from trial and error programming, something that some people fall for when they resort to single step debugging in order to understand what their own code is even doing.

Compiling was slow because computers in general were slow, like single digit MHz. That enforced programming efficient code. It's also why we learnt about big Oh notation already at school. Starting with manual resource management helped to get a feeling for what's going on under the hood.

TLDR: Small family owned finance business woes as the “you-do-everything-now” network/sysadmin intern

Friday my boss, who is currently traveling in Vegas (hmmm), sends me an email asking me to punch a hole in our firewall so he can access our locally hosted Jira server that we use for time logging/task management.

Because of our lack of proper documentation I have to refer to my half completed network map and rely on some acrobatic cable tracing to discover that we use a SonicWall physical firewall. I then realize asking around that I don’t have access to the management interface because no one knows the password.

Using some lucky guesses and documentation I discover on a file share from four years ago, I piece together the username and password to log in only to discover that the enterprise support subscription is two years expired. The pretty and useful interface that I’m expecting has been deactivated and instead of a nice overview of firewall access rules the only thing I can access is an arcane table of network rules using abbreviated notation and five year old custom made objects representing our internal network.

An hour and a half later I have a solid understanding of SonicWallOS, its firewall rules, and our particular configuration and I’m able to direct external traffic from the right port to our internal server running Jira. I even configure a HIDS on the Jira server and throw up an iptables firewall quickly since the machine is now connected to the outside world.

After seeing how many access rules our firewall has, as a precaution I decide to run a quick nmap scan to see what our network looks like to an attacker.

The output doesn’t stop scrolling for a minute. Final count we have 38 ports wide open with a GOLDMINE of information from every web, DNS, and public server flooding my terminal. Our local domain controller has ports directly connected to the Internet. Several un-updated Windows Server 2008 machines with confidential business information have IIS 7.0 running connected directly to the internet (versions with confirmed remote code execution vulnerabilities). I’ve got my work cut out for me.

It looks like someone’s idea of allowing remote access to the office at some point was “port forward everything” instead of setting up a VPN. I learn the owners close personal friend did all their IT until 4 years ago, when the professional documentation stops. He retired and they’ve only invested in low cost students (like me!) to fill the gap. Some kid who port forwarded his home router for League at some point was like “let’s do that with production servers!”

At this point my boss emails me to see what I’ve done. I spit him back a link to use our Jira server. He sends me a reply “You haven’t logged any work in Jira, what have you been doing?”

Facepalm.

A lot of the string operations in Python, because they are named like shit.

First you have startswith. No underscore. Just two words glued together. No case notation, nothing. So ugly and difficult to remember when Python isn't your only language.

And then there's tolower. Wait, no, it's actually just lower. If we're gonna stick with the shitty naming, can we at least keep the two-words, no underscore thing? No, I guess it's easier to save those two characters.

And isupper, the function to get supper from your iPhone.

Yeah, it's small. But aren't most of our gripes about languages tiny anyways.

In the Ruhr area (Germany) we have some very old, very strange words with strange meanings. One of those words is ‚Prutscher‘.
A Prutscher refers to a person who does things but never gets a good result, due to lack of knowledge or simple carelessness. Most of the time, Prutschers are people who are interested in certain subjects and often work in the related jobs, but who lack the motivation to properly train themselves, learn what there is to learn and to always keep up with their technologies .
Here are a few examples I've stumbled upon so far in my career:

- Developers in their 60's who read a book about PHP 25 years ago and decided to become a software developer. Since then haven't read anything about it. Who then now build huge spaghetti monoliths for large companies, in which they prefix every function, every variable and constant with their initials and, of course, use Hungarian notation.

- People who read half a fucking tutorial about <insert any fancy js framework here> and start blogging/tweeting about it

- Senior web developers who need to be told what the fuck CORS is and who can't even recognize CORS related errors in their browser console.

- People who have done nothing else for 18 years than building websites for companies on Wordpress 1.x and writing few lines of PHP and Javascript from time to time. Those who are now applying as a frontend dev due to the difficult economic situation and are surprised that they are not accepted due to a lack of experience.

- Developers who are the only ones working on Windows in the team and ask their Linux colleagues for help when Windows starts bitchin.

- People who have been coding for 30 years, have worked with ~42 languages ​​and don't know the difference between compiled and interpreted languages ​​in the job interview.

- Chief developers at a large newsletter-publisher who think it's a good idea to build your own CMS (due to a lack of good existing ones, of course).

- Developers who have been writing PHP applications for multinational corporations for 25 years and cannot explain how PHP is executed. They don't even know what the fucking OPcache is, let alone fpm. FML

- People who call themselves professional developers but never ever heard of DRY, KISS, boy-scout rule, 12-Factor App, SOLID, Clean Code, Design Patterns, ...

- Senior developers wondering why the bash script won't run on their fucking Windows machine.

- Developers who consider Typescript to be a hindrance and see no value in it.

- Developers using ftp for deployments in 2022

- Senior Javascript Developer applying for a job and for whom Integer is a primitive data type in JS.

- Developers who prefer to code without frameworks and libraries because they are only an unnecessary burden/overhead and you can quickly code everything up yourself.

- Developers who think configuring their server(s) manually is a good idea.

You fucking Prutscher. What you have already cost me in terms of work and nerves. I can't even put it into words how deeply I despise you. I have more respect for the chewing gum that has been stuck in my damn trash can for the past 3 years than I do for you guys. You are the disgrace of our profession. I will haunt you in your dreams and prefix every fucking synapse of your brain with MY initials.

As a well-known german band once sang in a very fitting song: I wouldn't even piss on you if you were on fire.

If you recognized yourself in one of the examples here: FUCK YOU!

Yknow, I want to make an android app that I have in my mind for about half a year now and I already tried twice, both with Kotlin and with Java but everytime I try it's just pain and suffering and frustration...

No it's not because of the language, I like Java and I like Kotlin too and I'd say I'm at least decent at Kotlin and really good in Java...

No no.. the issue is the fucking Android SDK and the mix-and-match documentation available online!!!

Every fucking time I want to implement some sort of UI element, user action or a background service and I start googling how to do it It comes with with at least 3 different stack overflow solutions, all of them saying "that way of doing it is deprecated, instead you should X" and looking up the OFFICIAL FUCKING DOCS it will just make me roll up in the corner and cry because of how fucking inconsistent it is and the retarded domain language it uses... fucking transactions for fucking fragments inside fucking activities... because I guess the word "screen"/"view"/"template" or something similar natural just was too mainstream for the all knowing alphabet soup that google is...

And then you start looking up what the fucking difference even is and how to code it up only to find out there's at least 12 other opinions on how fragments should be used and what should be an activity and what should be a damn fragment...

But that's not all, that's just the base... I get a headache even thinking about how the fucking inflating of templates and the entire R. notation works. You want to open a fucking tiny corner menu with the settings options? WELL THEN YOU FUCKING BETTER REMEMBER TO IMPLEMENT IT THROUGH SOME SORT OF EVENT AND INFLATE THE MENU YOURSELF EVEN THOUGH ITS THE SAME FUCKING THING WITH STATIC STRINGS...

AND WHY THE FUCK DO I NEED LIKE 4 NEW FILES TO IMPLEMENT A FUCKING LISTVIEW...
also talking about ListViews... what was wrong with "ListView"... Why do we need a "RecyclerView"... oh right... because the fucks fucked the fuck up and all the legacy components were designed by a monkey and are next to useless! SO WE NEEDED A NEW NAME FOR THE FIXED VERSION, CANT NAME IT LISTVIEW AGAIN... FUCK YOU...

honestly... if I got a dolar for every "what the fuck android" I said during trying to understand that mess I'd be richer by a few hundred...

oh oh oh, but you know what? You don't like the android SDK? that's fine, you can use fucking React or Flutter or something... yeah.. because instead of torturing myself with the android SDK I want to torture myself with an abstraction of the same SDK and JavaScript as the fucking cherry on top... HAVE YOU FUCKING SEEN THE CODE FLUTTER SHOWS ON THEIR WEBSITE AS THE "Introduction" ?!!!

Look at this piece of shit:

[code in attached image, we could really use a proper Markdown support at least for rants]

THAT'S NOT EVEN THE ENTIRE THING, THAT'S JUST THE *REALLY* UGLY PART...

The fucking nesting... What is it with JS and all the fucking nesting everytime?! It looks like shit.... It reads like shit as well...

WHY, in the name OF FUCK, IS THERE MORE THAN 5 ANDROID FRAMEWORKS and ALL of them... used this FUCKING NOVEL idea of programming using A FUCKING BRACKET WALL

It always looks like:
(code(code[code{code(code{code()})}]));

If I wanted to make a fucking app or a website using fucking Haskell I'd do that.... at this point reading assembly code feels like heaven compared to this retardation... Why is this so popular?! WHAT DO YOU PEOPLE SEE IN IT?! Clearly it's not the aesthetics... it looks like a fucking frog vomit running down an emus leg, fuck that.... I don't even hate classic JavaScript, it's a good enough language and it does what I tell it to... but these ugly fucking frameworks like react, angular and whatever else uses this fucking format can go fuck right off. This is not the way JS is gonna get a better name for itself...

So:
Fuck Google

Fuck the marionette that designed the Android SDK

Fuck the Hellspawn the came up with the "functional-like" way of using JavaScript

Fuck everyone that thinks "JavaScript everywhere" is a good thing

And deeply future-fuck everyone that makes a new framework following any of these standards, stucks a .js at the end of the name and releases his hairball.js of an invention into the fucking world....

It's a mess... fuck everything android related...

I feel like my legacy has begun. I hear people using a notation description that I think that I invented.

When one does port mapping in commands it is like this: 5432:5432. Nobody remembers which port comes first unless they the command a lot. I confidently referred to it as "reverse cotton eyed joe notation" in a meeting.

"Where do you go? Where do you come from Cotton eyed joe?"

Can someone just please come over and safe me? I am soooooo done with all this bullshit code. I understand why people loathe PHP, it enables totally worthless people to carry the title 'programmer' because hurrrdurrr look at my website, I made this. Fuck yes, you made that and you should SHAME yourself! What the actual flying fuck I can't begin to explain the monstrosities that I find checking out this worthless pile of fucking garbage.

User passwords saved as plaintext in database? Check!

Using hungarian notation, camecase and snakecase inconsistently? Check!

Typejuggling like you're the mainman of the Insane Clown Posse? Check!

Everything is a mess, there is no documenation, no consistency no nothing, this is straight from the 9th circle of programmers hell.

Aaaaaaarghhhhh I AM SO FUCKING DONE WITH THIS WORTHLESS PILE OF GARBAGE!!!!

The original dev prefixed every spagetthifile with his copyright shite so im gonna look him up and highfive him in the face with my laptop and after that printing out my resignation letter in comic sans fontsize 78 because FUCK YOU

So done.

I don’t like to judge people based on what languages they like (because I like all of them). But I can’t deny the pattern anymore.

Smart people know and enjoy smart languages: Smalltalk, OCaml, Clojure, Lisp, Haskell, etc. They may use JavaScript or PHP to make money, but ask them to code in their smart language and they’ll be more efficient. Getting old, some of those people say “screw it” and find a Haskell job.

You, my friend, are not one of those people. You are VSCode-dwelling goblin who thinks lambda calculus has something to do with JS arrow function notation, is scared of reduce() and not even good at the single fucking language they know.

Insta coders and that mechanical keyboard collector dorks are not “superstars” you got to be like.

I'm a junior dev and my seniors insist to use Hungarian Notation. Looking the code I found a variable called oAllProjects... This is a fucking array.

Time for a soap box rant.

I just found this in one of our projects. I've simplified the example to make it more anonymous.

When I see code like this it automatically means there is a lack of attention to enumerations and/or understanding of what they are.

One may argue that in a certain execution of code it's a minor performance hit and therefore insignificant. It's still a performance hit. Furthermore, it takes even less time to do it the right way than it does to do it the wrong way.

Every one of these lines will enumerate the list from the beginning to try and find that one element you're interested in. Big O notation, people.

Throw that crap into a dictionary or hashset or similarly applicable data structure with direct reads at the beginning of your logic so that it only gets enumerated ONCE when the data structure instance is created. Then access it however many times you want.

Soap box rant over.

Since we're limiting this to things on my desk I can't do any more deep cuts out of my calculator collection, but this one is still somewhat interesting.

The HP 32S was my friend throughout university, it replaced the 15c I used before which does not live on my desk. The notable thing about the 32s is the fact it's an RPN calculator. RPN calculators are the best way to have friends never ask to borrow your calculator. The exchange will start by them asking to use it, you saying sure, and them handing it back a few minutes later without saying a word.

There's two kinds of people in this world. People who go "wtf" in an interview when asked to create a calculator program using a stack, and people who were oddballs and for whatever reason used reverse polish notation devices.

For those not familiar, rather than entering values into the calculator in "10+10" fashion, you instead provide it a compositional set of values until an operation is provided (10,10,+) at which point it executes. The why is, this type of operation allows the calculator to more naturally process operations, and eliminates the need for parenthesis which makes the operations less error prone in practice and easier to track.

The 32s had a 4 year run before being replaced by the 32SII. In the same way using a Curta will give you a significant understanding of how radix computations and floating points work. Using an HP 32s (or any of its predecessors) will do the same for algebraic functions, because you had to program them yourself using a basic label address system that also had subroutine support.

Kids who grew up with graphing calculators don't know how good you had it 😋

css quick maffs

so, you want to make a css gradient from a certain color into transparent. The logical way would be doing it like this:

linear-gradient(#112233, transparent)

however, this will cause a blurred black stripe to appear in safari. This is due to safari-specific algorithms (that also make it the quickest browser, especially on arm-powered macs).

stackoverflow and other boubas will suggest doing this:

linear-gradient(#112233, rgba(255, 255, 255, 0))

this is better, but instead of a black stripe, a half-transparent white stripe will appear.

To finally make this gradient render consistently across different browsers, do this:

linear-gradient(#112233, #11223300)

Now, you're only changing alpha. See, CSS is a declarative language, so you should be telling it EXACTLY what you want to achieve. You don't want to change one color into another (in that case, "#112233" into "transparent", yes, they are distinct colors that are totally different. CSS doesn't treat "transparent" in some special way like we do) but to only change the alpha channel of #112233.

Feel free to use rgba notation if you want to support older browsers:

linear-gradient(rgba(11, 12, 13, 1), rgba(11, 12, 13, 0))

aight bye

JS interview:
– we expect you to know the concepts of immutability, persistence, software architecture and systems theory, methods of analyzing complexity beyond the big-O notation, safe parallel code execution with web workers, WASM, modern web standards including working drafts, progressive enhancement and graceful degradation, WCAG recommendations and web accessibility in general, UX strategies and modern graphic design trends. Nice 20k github stars you got there. By the way, what's your opinion on modern optimistic UX?
– I know this all but I somewhat disagree with some status-quo UX strategies
– unfortunately it's a no

PHP interview:
– Do you know how to wipe your ass?
– *excited hysterical jumping with head nodding*
– You're hired

Currently doing a lab in XQuery. The comment notation always makes me smile :)

aaAAaaAaaAaaAaAAAAAaAaaa floating points!

I debugged my algorithm for quite a while, wondering why it sometimes gives out "Circle(Point({1.7976931348623157E308,1.7976931348623157E308}),1.7976931348623157E308)" as the smallest circle around a group of points.
Figured out that it sometimes just never found any circle defined by two or three of the points which included all points (which is mathematically impossible).
Then finally I made it print out the points it thought were not inside the circle:
"1,7,8: Circle(Point({0.6636411126185259,0.535709780023259}),0.4985310690982777)
skip, 1 not inside"
So it defined the circle with 1 being on the edge, but then thought 1 was outside. Thank you, floating point Math.

For anyone wondering about the notation: That way I can directly copy/paste it into Geogebra to have a visualisation.

So I did an interview today and the problem was given a = 1 2 3 and b = 2 3 write code that finds the common elements.

I asked what the data structures are and they said it can be whatever so I said cool then we can use sets and do an interception to get unique elements.... this was in Python... but for the life of me I couldn't remember what the intercept notation was... and brought that up hoping they're give me a hint haha.

So I ended up writing a 8-9 line solution for what could've been a one liner fml: return a | b.

All because I didn't know the notation and still needed to give them something. Painful to write when I knew I was reinventing the wheel. Sign

I almost never use sets so this was heartbreaking hopefully I still get an offer!

How bad of a fail is this in y'all opinion?

Why is it that virtually all new languages in the last 25 years or so have a C-like syntax?

- Java wanted to sort-of knock off C++.
- C# wanted to be Java but on Microsoft's proprietary stack instead of SUN's (now Oracle's).
- Several other languages such as Vala, Scala, Swift, etc. do only careful evolution, seemingly so as to not alienate the devs used to previous C-like languages.
- Not to speak of everyone's favourite enemy, JavaScript…
- Then there is ReasonML which is basically an alternate, more C-like, syntax for OCaml, and is then compiled to JavaScript.

Now we're slowly arriving at the meat of this rant: back when I started university, the first semester programming lecture used Scheme, and provided a fine introduction to (functional) programming. Scheme, like other variants of Lisp, is a fine language, very flexible, code is data, data is code, but you get somewhat lost in a sea of parentheses, probably worse than the C-like languages' salad of curly braces. But it was a refreshing change from the likes of C, C++, and Java in terms of approach.

But the real enlightenment came when I read through Okasaki's paper on purely functional data structures. The author uses Standard ML in the paper, and after the initial shock (because it's different than most everything else I had seen), and getting used to the notation, I loved the crisp clarity it brings with almost no ceremony at all!

After looking around a bit, I found that nobody seems to use SML anymore, but there are viable alternatives, depending on your taste:

- Pragmatic programmers can use OCaml, which has immutability by default, and tries to guide the programmer to a functional programming mindset, but can accommodate imperative constructs easily when necessary.
- F# was born as OCaml on .NET but has now evolved into its own great thing with many upsides and very few downsides; I recommend every C# developer should give it a try.
- Somewhat more extreme is Haskell, with its ideology of pure functions and lazy evaluation that makes introducing side effects, I/O, and other imperative constructs rather a pain in the arse, and not quite my piece of cake, but learning it can still help you be a better programmer in whatever language you use on a day-to-day basis.

Anyway, the point is that after working with several of these languages developed out of the original Meta Language, it baffles me how anyone can be happy being a curly-braces-language developer without craving something more succinct and to-the-point. Especially when it comes to JavaScript: all the above mentioned ML-like languages can be compiled to JavaScript, so developing directly in JavaScript should hardly be a necessity.

Obviously these curly-braces languages will still be needed for a long time coming, legacy systems and all—just look at COBOL—, but my point stands.

mFriends don't let sFriends use hungarian notation

Spending hours upon hours trying to understand C# entity framework relational data mappings, going to the extreme of looking at LINQ queries, writing and rewriting over 100 lines of code only to find I needed to write the joins in dot notation on the include!

I have been waiting on a data file for days now and when I finally got my hands on it I discover that excel converted the IDs into scientific notation when they exported it.

Thank you, Microsoft, for yet another delay in my work.

Fuck PHP scientific notation

Who the fuck invented Hungarian notation?

lpszName, bVisible, pNext, ppData...

A variable's type should already be clear by its name and scope. If not, get yourself some decent IDE that helps you out. Why this style is still in use in code like the Vulkan API is beyond me... IT IS NOT USEFUL!

Worst part of coding lang I love?

C# being case-sensitive.

Not a C# language thing, but I hate the vilification and anti-coding standard of not 'allowing' prefixes. Interfaces are allowed (ex. IUpdateCustomer), why not classes? Why can't I have a DTO and declare it a TCustomer and the zealots not scream "HE'S USING HUNGARIAN NOTATION!!! TAKE HIM TO THE STAKE!!"?

In an algorithm class, professor introduced us to some simple search algorithms (bubble sort, selection sort, insertion sort, shell sort). He did a quite decent job and most of the students were able to grasp the code and understand the differences in those algorithms. But then he spoiled his whole lecture with one additional slide. There he proposed an optimization: Instead of using a temporary swap variable, we just could use the first array element (or the zeroth element, respectively: the one ad index 0) for doing all the swapping. We just had to document that, so that the caller would "leave the first position of the array empty", resulting in "cleaner code". And he did that in the same class where he used Big-O notation to argue about runtime complexity. But having the caller to resize the array and to shift all the elements by one position did not matter to him at all, because it was "not part of the actual algorithm".

One problem for CS education is that the salaries for academia are so low compared to industry that if someone is even vaguely competent, they can at least double their income by working a 'real' job. Now this may be different at higher levels of colleges but generally those folks are such bullshitters they wouldn't last outside of academia.

As what to improve?
Depends if it's a research or vocational course.

For vocational; heavy on group projects, common tools, methodologies and architectures. All demonstrated in something like c#/java/python. And one project must have a web app (db, app layer and JavaScript from end)
Basic knowledge of algorithms, runtime analysis (O notation) and some data structures and you're an instahire.

For research, go wild. Deep dive into the math, algorithmic side. Read up lots of research papers. Try out different programming paradigms. You would aim for a career in academia, AI, quant finance etc...

I freak out when I see cryptic maths notation.

Did I get old or did I just finish plucking all the low hanging fruit?

When I started on a programming journey about a decade ago everything feel exciting and I learn a lot of things per day (variable,loop,method,class,---etc)

Now a decade later I am more concern with the overall system design,algorithms usage (Big O Notation),how reliable the system it,and how the configurations are set up and how easy is it to change them.

I now notice that I don't really learn anything learn new.Everything feel the same.

Want redundancy? Use more server

Want faster performance? Make a parallel system.

Want program to run on low end device? Think about how memory and storage will be used in system.

Is this a stage everyone went through like puberty? or I am just having a mid life crisis?

PS : I haven't even reach 30 yet but I feel too old.

I guess I should relate what work experience I have: my internship.

A little backstory I suppose. It's required at my school to do an internship to graduate except under certain circumstances. They encourage work experience a lot where I study. It was around time for me to apply for internships. However, the closest I got was a phone call with Amazon that I biffed when they started asking about stuff like sorting algorithms and other Big O notation stuff. So I was pretty desperate. I found a small company that were looking for internships and got an interview with them. The pay was dirt (I made more as a crew trainer at McDonalds) but I needed that internship and they were only 10 minutes away.

Immediate red flags when I showed up to the address. At first I thought I was wrong, But I noticed the sign of the company pointing up some stairs that were installed on the side of the house I was in front of.

Interview was a bit weird. It was with the CEO and the marketing manager. Again red flags. I show up for work a week later.

Turns out, they have no full time developers. 1st day was getting my workstation ready and 2nd day I was running Ethernet cables to the basement where the phones were connected. Spent around a week doing that.

This was supposed to be a Software Engineering internship?? Excuse me?? I came here to learn how working on Software is supposed to be like! I was also their "tech support" both for their computers and their crappy software that was built 16 years ago that people still pay for that I had NO idea how it worked because I just started and NOBODY taught me anything! To make matters worse, even if I wanted to delve into the code to see how it works it was all made in ancient Perl which didn't make things any easier.

But I needed that internship to graduate. And thus begun my 9 months with them and boy howdy I have stories to tell. Stay tuned in the future.

Me: Interview is in 3 hours, I'm prepared, it's non technical anyway, just be yourself.

Brain to me: What the fuck is big 'O' notation? Objects you mean chairs? Turing? That's some kind of robot right?

Also me: fuck....

C++ Really confuses me... I mean why when defining an array variable is the array notation on the variable name rather than the variable type?

**Yoda conditions**
(also called Yoda notation) is a programming style where the two parts of an expression are reversed from the typical order in a conditional statement.

Hi fellow ranters,
Its been awhile since I last was here posting stuff..

So, I've commited to my effords getting shit done in golang. And I met a lot of painpoints, and I mean...
A
Lot
Of
Them.

Anyway, most of them are solvable by changing mindset or having some macros set up for no-one-fucking-wanted bloody boilerplate code that is omnipresent fucking EVERYWHERE.. **cough**
Steering back on what I want to rant about.

We with our team have one major problem with golang. There is no standard for docs in code...
Like, Fing legit. Everyone uses notation for closest to theirs heart language, so you get inconsistent-as-fuck notations for parameters / function descriptions.

We have functions that look like
//doSth does something
and also
// doSth
// @Summary does sth
// @Description does something but in more words
// @Param
and so on and so on

And trust me Im getting mild example.

Why this language does not have A F...ING (well defined, using proper definitions) STANDARD YET?

EDIT:
bonus context: We decided that too much of our code is undocumented and we go through efford of documenting it, but everyone sees it differently, and we can't agree on one single standard... So we decided to not refuse PRs due standard, as well, nobody would ever had PR accepted

This is probably a standard pattern/algorithm, but I feel pretty good about myself figuring this out.

I was doing a programming challenge and found myself with 2 lists of integer points (x,y). I needed to see where the points converged and identify those locations. Of course I started with a brute force approach and did nested loops to find these locations. This was taking WAY TOO LONG. These lists were 200K each. So checking with naive looping is 200K * 200K operations. Which is a lot.

Then I thought, well I am checking equality, so I will create a third map. The index to the map will be the point, and the data will be an integer. I then go through each list once incrementing the integer for each point that exists in each respective list. Any point with a value greater than 1 is a point convergence.

Like I said, this has got to be a standard thing, so can someone tell me what algorithm this is? I am not sure how to search for this.
I am fuzzy on complexity notation but I think the complexity started at n^2 and was reduced to n. Each list is cycled over once.

Chess game: EVERYONE is allowed to participate and move.

Rules:
-once you played a move for one side, youre not allowed to change side
-if you cant visualisate the board, use a real board.
-no takeback
-dont do sabotage!!
-let others play too. Youre not allowed to play three moves in a row.
-use algebraic notation
-if youre black, write three dots in front of your move ( 1. ... d5)

GOOD LUCK!

Im starting with

1. d4

Android devs, what are your thoughts about the naming conventions google tries to enforce on us, especially with the xmls?

I opened a new project after months of leaving android dev, and thought of trying the basic activity template with name 'myActivity'

On clicking it, a ton of files got created : myActivity, myActivityFragment ,... And in xml the reverse naming notation : activity_my, fragment_my, content_my,...

This naming is uncomfortable .in a large project, activities usually acts as complete modules in which different tasks are handled : logins getting checked, data being cached, database being accessed and much more...
So if my activity 'abc' has a content fragment and a toolbar whose design is in another xml, shouldnt the 3 of them be named like:
abc_activity.xml
abc_activity_fragment.xml
abc_activity_toolbar.xml

And not
activity_abc.xml
fragment_abc.xml
toolbar_abc.xml

??
At the very least , it would look nice since the components that are displayed together will have their files together. And i don't know much about testing, but i believe it would be helpful there too

Once I helped one of my friends writing a coding project for an interview for him.

We worked out a solution in C++. I showed him all the class hierarchies, how the flow worked and so on.

The day after he told me he re-wrote it in C# as he was more confident with it. Fair enough.

He changed most of the names using camel + underscore notation, sometimes starting with a capital letter, sometimes not!

But the best (or, rather, worst) was to convert the class hierarchy in a big class with all stuff in it, called "CMother". That got me. This class had a couple of static methods that took a lot (if not all) inputs that somehow coincided with the member variables of another class and did some work with them (like a constructor of that class would do).

Needless to say, he didn't got the job

everybody nags about php inconsistencies, but have you tried excel vba scripting and adressing a1 vs r1c1 notation regarding ranges and names? pure horror.

I don't know why but here, in iran, everybody use Hungarian notation? Like strName or txtFirstName.
I think its silly and i hate it. is it common everywhere?

At the very start when I learned my first language. Didn't know where to find the "{" and "}" keys on the keyboard. Thought I would never be a dev, since I couldn't write a program without those keys.
Or when I didn't understand the notation of accessing values inside an array. Thought things like array[0] would do some magic to the array and didn't know how to access other parts of an array. I was following a book back then.

Teammate used some excel sheet concoction/gimmick to execute hundreds of thousands insert statements on production tables. A few days later (when I'm on call), I find out he didn't adjust the cell formatting on the aforementioned excel "tool", so all the network addresses from the insert statements were put in scientific notation, on prod...thus breaking a lot of the things. FML

everytime i try to learn kotlin, i can only think WTF is happening, why should it be happening?

after wasting last 4 hours, i came to this conclusion table regarding kotlin var and val notation.
And now my fucking compiler is saying that i can rather write :

val x:Int

and initialize it later, when i thought val is immutable and must be initialized at the beginning only(like public static final int x =5)

Who the fuck are those people that like this stupid language? why would you say some variable as immutable(meaning which can be changed 0 Times "ONCE" ASSIGNED A VALUE ) and when i can create a program with a variable that never got ASSIGNED A VALUE EVEN ONCE??

big o notation is confusing

Just got a code to work where guys used Hungarian Notation... What do you guys think of this?

commodore amiga 500, when I was 5 or 6.
what was the very first thing on it that i experienced, i don't know, but some things i remember:

Cannon Fodder 2
A-Train, a game that i played for months, it utterly fascinated me and i was utterly unable to keep my company afloat, because i was utterly unable to understand how the mechanics of the materials moving around worked (i still don't, actually, but in a different way)

some Apache simulator, which took us (me and father) literally a week to figure out how to get into the actual game from the main menu stylised as a military office. it took us several days to even realize it's the menu.

the Lotus Esprit 2 game, which we played regularly.

some Airbus simulator where i took two weeks of trial and error to figure out how to take off, without manual.

some experiments with midi sequencing and notation music programs.

how every two months, dad came with a 20page long list of programs and games from some pirate seller, which we would go through, mark stuff that sounded interesting (going by name only), then he would send it by post to him, and after a week, we would go take a package from post office full of floppies, literally like 200, and the next two or three weeks, we would be trying all of it out, seeing what the things we got were about, putting the good ones on one pile, the boring ones on another (cheap floppies for use)...

ah the magical times of wonder and exploration...

Do you know the "Boobs Bonus"?
For example, in an IT School, if your project group have at least a girl, your group have some bonus points on your notation ... I hate this for many reasons 😡!!!
Teachers deny & hide this fact because it's now a "tradition"

My instagram feeds wooww
Big Setup with laptops pc phone etc .. hot guy or glzz.. and a big caption lets learn big O notation .. hehehe

Who is using Hungarian notation for js?

i'm sitting on the bus a few years ago, slamming the keyboard on my chromebook to try and get a wifi password. open crosh by accident. i went to check it out for a few days. i check back a few years later, every tab (basically everything for CrOS) autocloses if it has "crosh" in the url (regardless if it's crosh or not.) this pisses me off. i tell my brother about it, and he gets the terminal running for one day. how? i still dont know, sadly the program he installed (a harmless music notation app) breaks as well as the terminal. to this day i still wonder about what our IT department was thinking.

The UML specification book satisfies OCD quite well I'd say.

Page 59, the actual content hasn't started yet, but I'm happy: "Within each clause, there is first a brief informal description of the concepts described in that clause. The clause is then
split into sub clauses, each describing a coherent set of concepts that constitute a portion of the formalism specified by
the clause. Each sub clause is then split into Abstract Syntax, Semantics, Notation, and Examples.
"

While building this site I decide to check if it works in internet explorer (you know, would be kinda nice) only to find out that apparently even edge does not support the js notation:
class MyClass {
// Stuff here.
}
Throws an exception 'MyClass' is undefined... Fuck you ie. Making me rewrite my damn classes.

Do you put Caps to public variable ?

My IDE was doing caps to public variable but someone told me that he was wrong it's not caps for public variable only functions.

A system to build note-taking systems. tatatap dot com.

It’s the most successful for a few reasons: it got launched, people find it useful, but most importantly it’s been fun and continues to be fun to work on.

I think the fun-to-make factor is massively underestimated as a success indicator. Working on the right product (whatever that means) that is unenjoyable is like using an amazing computer with a broken keyboard. It’s never going to work.

Sure, with any project there’s annoying stuff, but it’s the trend overall. Is the core functionality fun to work on?

In the case of Tap the core component is a notation parser, open sourced called sowhat, github dot com/tatatap-com/sowhat

That was super fun to make and learn about lexing and parsing. It’s pretty far along but there’s still a lot I’m planning to add.

So since as programmers languages are nothing but notation why do we even bother, and why not just make lisp a unified notation for all programs?

Jackson has this adorable option of an array sintax to represent every object on a JSON where the first element of the array is the classpath of the type and the second is the object itself and someone thought it would be nice to use this notation on a REST API...
why?

Can anyone recommend some good resources to brush up on Big O notation?

I’ve bought some books etc, but just looking for more information.

I stupidly applied for a job at a FAANG company, and they’ve invited me in for an interview (thought I’d get knocked back at the sifting phase).

Can anyone recommend resources on learning/revising big O and big Theta notation?

It’s the one thing that never seems to stick in my head, and the course material provided by university isn’t particularly useful.

I fucking hate Lodash. You don't need a fucking library to access an object property you moron. It's a native ability in JavaScript. Not my fault you can't figure out how dot notation works.

anybody else has a "polish notation fetish"? i never actually learned lisp, but since i first saw its style, i find writing functions like "+ 1 2" instead of "1 + 2" both aesthetically and functionally more appealing. i think the infix notation is just being kept because of well-established habits.

Anyone got some good links to introduce Big-O notation? I’m getting my head around it but still feel I’m missing the basics!

Some people should not be allowed to write #sass, seriously having a class in BEM like notation `level1--level2-somestate`.

Typescript contructor parameter/class property combo, as well as fat-arrow notation

What's your idea of a perfect number?
Mine is:

default decimal, prefix for binary, octal, hex

Integers in natural notation with strictly positive exponent

All bases allow natural notation, where the exponent is always a decimal number and represents the power of the base (0b101e3 = 0b101000)

Floats in all bases allow a combination of natural notation and dot notation

Underscores allowed anywhere except the beginning and end for easier reading