skysight-inc/HackerNews huggingface dataset:
At first, I thought this was going to be about the Solid Project (which is sometimes stylized as SOLID) by Tim Berners-Lee. It's not. That would have been fun.

Regarding SOLID principles being outdated, I disagree. The high level concepts of SOLID are good and just as relevant as ever. While the author proposes that code is now less risky to change, I would argue that the asynchronous, distributed systems that we often work with today are significantly more complex and error prone. The world also got hooked on dynamic languages for the past couple of decades, although it feels like that shift is slowly reversing. Software bugs have become a routine part of daily life, partly because there's more software but also because we build that software more haphazardly to achieve deadlines for ever expanding sets of features. Today, a large number of developers lack proper education or training and have relatively little experience. We work in teams where there's a lot going on besides writing code and there's more distraction around us than ever before. To me, there's no shortage of reasons to worry about changing a line of code. I spend a lot of my time trying to understand and reduce that risk so that I and everyone around me can be more productive in the long run. The SOLID principles are a useful guide in that effort.

That said, you may want to update your interpretation of SOLID within the context of your latest coding practices. For me, that meant applying SOLID to functional programming. At first this seems odd, since much of the language around SOLID implies the use of classes and object-oriented programming. But it turns out there is a lot of overlap between the philosophies of SOLID and functional programming. [1]

1: https://dev.to/patferraggi/do-the-solid-principles-apply-to-...
Yes. I tried using a flatpak of PyCharm and it blocked access to directories where some of my code’s dependencies lived. It was unusable.
A fool and his money are soon parted
I don’t think that people are concerned about the trades but rather the perverse incentives it creates in the long term. Incentivizes bribes for officials on classified committees, it encourages employees to be more active in trading versus actually helping the company, investing would be pointless as the price would be set by insiders. By definition, any trade against an insider would be bad. It’s tough to predict the effects on the economy but I think it’s reasonable to say these behaviors are suboptimal for an economy. It’s a valid question because even Nobel laureates in economics have advocated for removing insider trader laws. However, my opinion is that academics are short sighted by their assumptions of the world. Namely, they assume that the agents would still try to maximize the well being of the company. No model is sufficiently sophisticated to take into account what happens when people get on their brokers instead of dealing with issues as they arise. As an extreme example, after noticing your data center is in fire, you clear your stock position before calling 911.

There’s a couple of key components to insider trading. First, you must be an insider. That is, loosely, anyone who has a some duty of trust. This can include public officials who are supposed to be serving the public and deciding to profit in times of crises instead of doing their job. This was not always the case. Furthermore, there is some notion of gaining information via illicit means also makes you an insider. The other is trading on material non-public information. “Valuable information” is only half the equation. For this, I’m going to use Matt Levine’s (I think that’s where I got it) example of how grey it can get. If a CEO harasses you, you are perfectly free to take out a massive short before suing the company. If the CEO harasses an employee, depending on the seniority and location of the crime, it could and could not be considered insider trading. Anyway, this is why we have the courts.
Particularly in the context of low-resolution pixelated graphics using a limited color palette, WebP seems a strictly inferior choice to the universally-supported GIF.
(2019); discussed at the time: https://news.ycombinator.com/item?id=19252952 (191 comments)
This is interesting because uBiome was at the time described (NYT, blogs, etc.) as a way for citizen-scientists to contribute to the scientific process, submit your poop, contribute to science. Pre-emptively, yes there are (very) many problems with the scientific process as it currently happens, but this is a relativley new class of things "citizen science + private industry" that is definitely going to take some time to smooth out. In part the scientific community is likely somewhat ignorant as to the promises of the startup culture, and I suspect they will definitely become more cautious promoting these types of collaborations as time goes on.
https://www.shortform.com/blog/what-are-the-48-laws-of-power...
To me Single Responsibility means that the code should do one thing and one thing only, on the abstraction level which it exists.

The example given by OP is about ETL. Is that one thing or more than one thing? It depends on the abstraction level. If you are talking about a data access object, sure let it do all those things because when considered on that abstraction layer it does one thing, access data.

But if you are looking at individual functions or methods, that is one abstraction layer further down, then S in SOLID says you should not mix extraction and transformation, for example.

It all depends on context and SOLID are principles not law.
I did something similar many, many years ago

I had moved into a new apartment and the local telco had provisioned the wrong telephone line, delaying me getting internet by several weeks (Thanks Telstra!)

As a result I ended up "borrowing" internet service from a neighbour a few units down. Only to discover that his setup was utterly ancient. A Netcomm NB5 modem connected to 1.5/256K ADSL1 service

I quietly pulled the credentials out of the HTML page source, logged into his account and upgraded his service. Boosting his speed to 20/1, gaining unlimited downloads AND saving him roughly $40 a month!

I know there's "white hat" and "black hat" hacking. Is there such a thing as "chaotic good" hacking? Where you leave systems in a better state than you broke into them
One Man Invented Two of the Deadliest Substances of the 20th Century
Format and statically check your shell script
If I knew anything about Roman history I'm almost certain I could draw a parallel to the fall of Rome here.
IBM IBM's.

It's has and will continue happening forever as far as I can tell.
>>* you cannot really get at what he's talking about without understanding at least the surface-level French?*

Can't we? The specific example is certainly worse translated, like translating a song... Can't we get at the same idea using different words, wordplays, parabbles and such? Is the point that you cannot have the same thoughts or make the same points points in another language?
> Type errors are such a small time loss as a developer

It's not about the errors themselves, it's about the way that having a strong type system improves quality of life in general.

For instance, in a duck-typed language, you may have code which runs correctly 99/100 times, but with one specific case it fails due to type issues. These kinds of issues are incredibly frustrating and time-consuming to debug.

Also requiring type designations in function signatures makes code self-documenting. You can just look at the code which someone else wrote, and know exactly what the inputs and outputs are. In a dynamically typed setting, there's often guess work involved in exactly what's accepted by a function, and unless it's very well documented you might have to go into the implementation to see exactly what is happening.

I didn't read the articles you linked in detail, but at least the first I would take with a grain of salt since they use Java as the exemplar for typed programming. Java is notorious for having a cumbersome type system.

In my experience, without types you might get a slightly faster time to first result - but in the long term, once a codebase gets to even medium size, types save you much more time than they cost. Especially since they become automatic after a bit of experience and you don't even think about it anymore.

There's a reason Python and Javascript are trying to add types, and why none of the most interesting languages of the past decade have been weekly typed.
That seems like a crazy definition, since fully realized it expresses the idea that people should be able to make large trades atomically without moving markets.
No, it's just that in a union the crime flows the other way.
>there are virtually no realistic use cases where you'd continuously override data that you just stored on your persistent storage.

Rolling cache or a large number of camera feeds that you only want to keep for x duration.
Recast as ‘Stimmies,’ Federal Relief Checks Drive a Stock Buying Spree
I wasn’t comparing it to anything. I was just writing more of the studies findings.
Interesting! Did not know that before! That would point to bell curves (at least in statistics/probability theory) being the Identity Element of the algebraic topology (or perhaps "set/numeric mapping" is a better word) created by applying Fourier Transformations to Statistical Curves...

Which just got me to think about the following idea... (Thank you for your post, BTW! -- Without it, wouldn't have thought of the following idea: )

Let's say that we consider the whole of 3D objects in Algebraic Topology (perhaps I am getting my terms wrong here, I am not a professional mathematician, so please correct me if I am wrong), but we consider the whole of objects that are formed by packets of vectors in 3D spaces, or perhaps curves in 3D spaces...

OK, so now what happens when those are Fourier Transformed?

And, are there any 3D objects (curves, vector packets, etc.) -- whose Fourier Transformation -- is itself? (That is, it's an Identity Element?).

Now... same thing, but for objects in higher dimensions (4D, 5D, etc.)... and if you can do all of that (I can't! <g>), then what's the takeaway from that?

Note To Future Self: Reinvestigate this...
RxJava SubscribeOn and ObserveOn Demystified
That's the point where you need refactoring. The basic problem is that you cannot look into the future and clearly see what exactly you are going to need (if you are lucky enough to implement something along a specification, you should us that knowledge though!).

As long as you manage to keep artificial complicatedness out of your code, you will always have the complexity of the problem mirrored in your code. A common problem of ideas about object oriented programming like SOLID or Clean Code is that they have a focus on classes. If you keep your classes very simple, you will instead end up with a complex architecture, where you might have zero responsibility layers or functions that just pass on the call further to a layer down.
Prehistoric tools replicas made using authentic tools and methods
You can also plant trees by yourself. Last year I planted 10 Siberian and Korean pines in one day. 7 trees survived, 3 trees died because I over watered them. So those 7 trees don't actually need any extra care from me.
But arguably some of that issue could be helped if you had good type systems on both ends. How much data is poorly formatted because somebody just hacked it out of some system with whatever scripting language?
Well, you answered your own question. Many devs don't use C++ (unless they're forced to). And they consider C++ at least as complex.
This feels like a great time to mention that insider trading is perfectly legal for Congress and is insanely profitable for them.
Well a kindle is actually $110 when it's not ad supported and boox is selling a comparable device for $185. So very similarly priced.

I would suspect the boox actually has more capable hardware because it needs to run android 10. I don't care enough to check though.
To me, there is one fundamental principle:

Better code is the one that takes lowest time in total to get from point 1 to point N by mediocre developer and in the same time result in lowest amount of help desk tickets

Its the essence of MIT vs New Jersey design style (i.e. worse is better)

The problem is, its impossible to measure that (unless we tap in parallels universes) which is why design is a form of art in real world.
Well, that - "any" software becoming a framework - does happen, but not all the time. Why does this matter?
> Should reinfection prove commonplace, and barring a highly effective vaccine delivered to most of the world's population, SARS-CoV-2 will likely become endemic.

The thing is, we don't know if reinfection will prove commonplace. We don't know how long immunity will last given a two-shot regimen—though the strong immune response that people are having on the second shot might be cause for hope. We don't know how the virus will mutate on it's point/spike, the main infection vector that the RNA vax target. We just don't know.

Research is emerging, time will tell. In the meantime, it's fear mongering.
Ask HN: K8s HPA vs. VPA?
In a nutshell, when would one want to use horizontal and when vertical pod autoscaling Kubernetes setup?
I'm not arguing that it's not a real thing, but how often does the LSP come up in your day to day life as a programmer? I have not thought about this once, and I do not think there is a problem this has solved for me in 10 years.
I don’t think that’s crazy. I think most people think it’s fair that the plumbing between their decision and the action shouldn’t be used to profit from them. Of course it happens in tons of ways. But that’s the general feeling. They want to see an order book, and if the book quotes X price, the seller won’t change it when they click the Buy button, etc.
It's not that those roles are much harder to get as such. It's that the most effective way to get those roles is to work at GS (or an equivalent) first.
> We ended up setting up our C Corp and it cost us money (thousands total)

Using your Pricing page, it'll cost $4.141 to kickstart an LLC for a non-US resident. The biggest costs being "Form 5472/1120 Tax Filing", getting an "ITIN/EIN" and bookkeeping. That being said, if you assume doing the "whole shebang", then I think you got something here. Most of the services you happen to find just want to incorporate and get you out of the door. Incorporating is easy (and relatively cheap) but everything else is expensive and risky.

Another question: Why no Delaware C Corp option? I understand that you are targeting SMB, but for non-residents I think the C Corp makes more sense).
Just for clarity/augmentation/pedantic detail: you might be sedated and end up an a ventilator.

But ventilators are really bad for COVID survival and really a last ditch, long-shot chance try to salvage your life. Practitioners hold off on the sedation and associated required ventilation as long as possible to try and spare your life.
Yes that is definitely true, human language is very limited. Although, a paradigm is only as strong as it's adoption, and by reducing the barrier to entry (using common language as opposed to overly precise notation), the principles can spread faster and with less friction say inside of an organization. Nuance is always more optimal, for sure. How many people can rattle off the Fundamental Theorem of Calculus? I would think that most people remember the idea behind it, but not the precise mathematical definition. In fact, the definition learned in undergraduate calculus is not 100%, as early undergraduates are not expected to have the rigor and experience to handle real analysis.
As somebody who has been on the receiving end of an employer (well it was a university system, but still...) coming after my IP, it is absolutely worth having total clarity, in writing when it comes to ownership of side projects.

It seems like a lesson most developers learn. I took a job at a startup that decided after they'd started hiring to pass around an employment agreement covering personal projects. Without talking to each other, apparently 3 of us 4 developers there had all politely refused to sign due to the side project clause. The only dev who did sign was the one fresh out of college. Ultimately developers were given a different contract than everybody else that made clear we owned our side projects and everybody happily moved on, but it was good that we all stood our ground on the issue and had clarity.
Unsurprising, really. I wonder if they can ever pull a SuSE and get out of IBM again, just as SuSE got out of Novell.
From my highly biased experience, I miss the dynamism all the time, but only for the specific reason of code hotloading.

I love Emacs for its extensibility and the capability to make changes to the system and see them immediately. Until programming languages like Mun catch up, I doubt it would be possible to replace Emacs Lisp with a statically typed language and retain the same amount of extensibility. Part of the requirements would be having the ability to replace the implementation of any function in the system at runtime, and that's the kind of thing you have no choice but to design your language from the ground up to include.

I guess what I mean to say is that it's not static languages that make me miss dynamic language features, it's that there's no statically typed language that supports the runtime hotloading that I can accomplish with a few Lua scripts (and has enough community traction to support something like LÖVE 2D).

Steve Yegge wrote an article related to this. He suggests that people who use static type systems are mostly trying to catch errors at compile time, errors which have no relevance after the typechecking is over with and the code is run (in the sense that machine code has no understanding of types). Static and dynamic languages will both ultimately output machine code that does the same thing, but one language incurs a massive penalty to flexibility of change. It's a rant, but it made me think that maybe you could have the type checking to catch errors at the time you're specifically looking for errors, and use the dynamism of the underlying implementation later on.

http://steve-yegge.blogspot.com/2007/01/pinocchio-problem.ht...
As nearly every poster in this thread mentioned, this headline is click-bait. I don't blame the author actually, this is very targeted click-bait (OO programmers) and I took the bait and actually enjoyed the read.

The criticism of SRP hits home for me - I try and write SOLID code when I can and SRP is challenging to follow. I struggle jumping between "Does this really fit SRP?" and "I can probably justify SRP here." I usually settle on the author's "Fits my head" and justify that when doing code reviews with my co-workers.

The author's comments on OCP don't accurately reflect my experience with the field of modern software development. I've worked on many projects (even green-field projects in the last 3 years) that have been very expensive and risky to change, where work absolutely needed to be additive because you couldn't trust refactoring tools to handle everything that needed to be changed.
All EU countries screwed up, not just Belgium. Case in point, German states agreed on an "emergency brake" once cases increase over 100 per 100k, 7 day average. Now we are there, 3 days in a row. So, one would assume they would close schools again. No, because it has to be 3 days in a row, weekends don't count so. After that, two days to implement measures. Which means schools will be open next week despite a heavy case load. Only to fulfill the political goal of opening schools before Easter. Nevermind we will close down everything after Easter through April.

There is no strategy, no planning, no logic involved.
Agreed - many tasks can be done with more accessible tools.

It's why Excel is so popular.

It's why modal editors suck for the majority of humanity. For most people and most applications, WYSIWYG is fine and allows people to use the computer to do their work.

We'll still need the more sophisticated tooling for a long time, but even that becomes more niche once it gets really good. Most developers are not writing assembly or machine code. Layers of abstraction can and do work, but every time a new one comes it's often viewed skeptically.

Nocode is a little different in the way that excel is limiting too, but that doesn't mean it can still solve a lot of the problem space for a lot of people if done well. Introducing young kids to programming seems like a reasonable place for it.

I think AI assisted programming will be interesting, both in the form of Karpathy's blog post: https://karpathy.medium.com/software-2-0-a64152b37c35 and also just to assist alongisde the dev. GPT-3 style, "center this on the page" -> correct CSS. Fast feedback via NLP here will be really interesting and helpful. We used to have to look up stuff in books, then there was google and stack overflow, it'd be nice to be able to ask random questions and get the answer instantly in code in front of you.

This is a great related blog post if you haven't read it: http://worrydream.com/LearnableProgramming/
But isn’t this caused by a lack of decent typing? If I had a well-typed API and a public schema, wouldn’t that be the better option?

Also you could just stick that in as an array or string (or var) to start with
She also said she'd block exports if they didn't get the rest of their order before anyone else, which given the 'negotiation' that went on is a bit rich.
Let's settle on it being a gradient from black to white.
His energy consumption argument seems to be false at a glance. I don't claim to be an expert but I can do some basic addition at least. If you have two components in consumption - "constant" and "variable", and if you have two components in production - "used" and "wasted", then adding strictly to the "constant" part of the consumption you also add strictly to the "used" part of the production. Constant energy receiver doesn't affect variable/spike part of production and consumption. To me it's an obvious conclusion, but of course being an amateur I may be wrong here.
Yeah, more than likely we are just going to have to buckle down and bear this. It’s a technology, and much harder to control than something like chemical weapons. It will just change the way society works, there is little we can do to stop it. All we can do is work to make authentication better.
Here's a sentence from the article with meme replaced with idea "One perhaps non-obvious consequence of seeing ideas as organisms is the concept of a idea parasites."

This seems to work fine.

Whether insight comes from calling an idea an organism is another issue, I suspect it's a poor metaphor.
An SBOM as part of a contractual requirement when purchasing software seems totally reasonable to me if the receiving organization already has the practice of checking a lot of versions and making sure they're sufficiently up to date. But the hard part there isn't the creation of the SBOM, it's a) actually using the SBOM, b) having enough contract power that if the SBOM turns out to be incomplete, out of date, or a lie, the purchaser can do something about it, and c) the purchaser doing something about it.

Nutritional labels only work in practice because a) plenty of people read and care about them, b) there are regulatory agencies that set standards and enforce compliance, and c) if they are too far off, an expensive class action suit is a real possibility.

My concern with starting with SBOMs is that since they're orders of magnitude harder to read and evaluate, and since many, many companies are already bad at tracking their own software patch status, approximately nobody will actually use them. Again, I look at the Equifax breach: it happened not because they didn't know what a vendor was up to, but because their internal processes weren't sufficient to turn knowledge into results.