ISO-morphism

> Simple != Easy

> For some, simple would be more like Haskell, while for others bash (until they need to understand old code). Each eye of the beholder can argue either way.

Certainly simple != easy, but I think in the second part there "simple" should be replaced with "easy". Simple is objective, while easy is subjective [1]. Haskell may be easier for some as they've spent more time with it, similarly bash for others. However, their simplicity, i.e. how many concerns are intertwined, how much global context is required to reason about a program, can be more objectively analyzed.

> The article talks about simplifying, though is more about discipline, something many find hard to find motivation and incentives for in this age of instant gratification!

Indeed, it takes discipline to maintain simplicity. Simplicity is hard. Complexity is easy. "If I had more time to write, this letter would be shorter."

[1] https://www.infoq.com/presentations/Simple-Made-Easy/

A git alias I found somewhere that I really like for displaying a history graph similar to bitbucket's:

  lg = log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --date=relative

> Clojure with the same exact constructs represented with more C-like syntax would, at the level the presentation speaks to, allow the same level of simplicity.

I don't think this is true. I think it would be easier for "most people," but definitely not simpler. Easy meaning close at hand, simple meaning one strand, one braid, independent, less context necessary. Clojure syntax is the AST of the program, right there in front of you, in literal notation. There are fewer special cases, fewer moving parts interacting. C syntax requires spinning up a virtual machine in your mind and executing multiple statements. C is easier because we've already spent the time and effort to familiarize ourselves with it, but it has more complexity. Compare a 954 line ANTLR grammar for C [1] with a 261 line Clojure grammar [2].

> Cognitive overhead is lower working with a language that at least "looks like", what you're used to, and more developers know C-like languages, thus a language like Kotlin is "easier to approach" but necessarily "easier" in the way the presentation talks about.

I would agree, using Rich's definitions of simple and easy, that Kotlin is easier for the majority of developers than Clojure. This follows immediately from the definition of easy.

> This is a misapplication of the presentation really. It speaks to a level above selecting a language and is really about the design of systems.

I would recommend Rich Hickey's talk "The Language of the System" [3]. The programming language(s) used are part(s) of the system and have an effect on its design. I don't think this is a misapplication of the "Simple made Easy" presentation, I think it hits the nail on the head.

[1] https://github.com/antlr/grammars-v4/blob/master/c/C.g4 [2] https://github.com/antlr/grammars-v4/blob/master/clojure/Clo... [3] https://www.youtube.com/watch?v=ROor6_NGIWU

This is Clojure. It's functional, but more as a side effect of focusing intently on simple, immutable, persistent data structures and their compositions. I'd strongly recommend looking into it, along with many of the presentations by its initial author Rich Hickey.

It's not about trying to catch attention, it's saying "I'm so good that even though this is totally unprofessional you're still going to want me"

I remember reading once upon a time about the sqlite file format being a good candidate for data transfer between systems/machines, as it's standardized, stable, and infinitely queryable. Has anyone here had any experience actually using it as such? What are your takeaways?

One of the definitions of wisdom that I've come to appreciate, similar to the article, is that "wisdom is taking your own advice." Upon reflection I've noticed that most of the time any advice that I give to others is tinged somewhat selfishly with advice to myself for a similar situation.

I share a hatred for this sort of thing that happens all too often the closer you get to hardware, mainly as a byproduct of the culture. However, refusing to adhere to a proprietary license damages respect for all software licenses, especially the GPL, in the global software community. Depending on where you fall on the anarchy vs rule-of-law scale that may or may not be a good thing.

Flip side of the argument: "Someone wrote a GPL library I want to use but I don't want to release my source. Is anyone really going to notice, care, or bother to bring the hammer down on my company?"

The parent was most likely referring to lisp, but note that there are other homoiconic [1] languages.

[1] https://en.m.wikipedia.org/wiki/Homoiconicity

Looks like Spacemacs [1], but for vim. Spacemacs has a more thorough "what is this."

Emacs is best thought of as a lisp virtual machine that happens to edit text. Vim is a hell of a text editor that happens to have a Turing complete scripting language. Spacemacs gives emacs a good text editor, while it looks like Spacevim is attempting to make extending vim easier.

The future of emacs and vim as platforms is interesting. Perhaps, at least for developer tools, we'll see more projects using these cross platform text editors as platforms for text based user interfaces in a revolt against electron.

[1] https://www.spacemacs.org

I think Poetry [1] is the most promising in the python build/dependency space. I've used pipenv and left dissatisfied.

[1] https://github.com/sdispater/poetry

Leave.

I think there's a very visceral part of seeing a human face do/say something that puts it in another league from text. Even though intellectually it may be known that both text and video are trivially forgable, I think it will be a long time before people truly start to question video.

Most start with good intentions. After realizing the power/advantage they have, whether it be from advanced technology, political office, or other position, they become jealous of it and find moral justification for clinging onto it despite conflict with their original intention.

There's probably a word for this sentiment that I'm not aware of.

I recently graduated from a middle tier state school in CS/Math. The CS portion required an ethics course, I believe its inclusion had something to do with an ACM mandate. Out of over 100 enrolled juniors/seniors I don't believe attendance ever reached double digits outside of 2 tests.

Sure, there was a "requierment," but I wouldn't really consider it legitimate. It took concerted effort to "earn" any grade lower than an A. I wasn't personally acquainted with any other student who seriously considered the social and ethical implications of computers during or after taking a 400 level course titled "Social and Ethical Implications of Computers."

On the bright side, I heard through the grapevine that rigor, or at least workload for the course, has increased since I took it.

Although anecdotal and perhaps specific to my institution, every recollection of my University career makes me feel deeply thankful that I ended up eventually pursuing a double major in mathematics. The quality and dedication of the instructors wildly surpassed that of the CS department. Mathematics professors were there to share knowledge. CS perfessors were pressured by hiring statistics into "preparing us for the workforce" by essentially quizzing specific interview questions like "what's the difference between interfaces and subclasses in Java."

Microsoft has a similar reference application [1].

There are comments arguing these architectures create a ridiculous amount of overhead for what would be a simple application traditionally, and others countering that the point is to show the underlying tech in the context of a "simple" problem. I think there's a large amount of truth for both sides.

It feels like there's a great paradigm shift on the horizon, and hopefully a good set of abstractions to build with. We're programming in machine-specific assembly languages, waiting for a high-level language to come along so we don't worry about things like calling conventions anymore.

[1] https://github.com/dotnet-architecture/eShopOnContainers

That's constantly polling the filesystem, isn't it?

I've never used it myself, but I know systemd has file watching built in. I think using `PathModified=/path/to/org` would also eliminate the need for entr [1].

[1] https://www.freedesktop.org/software/systemd/man/systemd.pat...

Totally unsubstantiated, but my opinion on why we use commas instead of the built in record/field seperator characters is simple: the special ASCII characters don't have a cononical printed representation and they don't have keys on a keyboard to make them easy to type. Therefore they're neither human readable nor human writable, and the human interface is really what matters with a plain text serialization format.

Edit: spelling

Here's Rich Hickey giving a talk in 2009 guided by Whitehead quotes [1]

[1] https://www.infoq.com/presentations/Are-We-There-Yet-Rich-Hi...

Yes, that's where tramp comes in, although s3 might need a separate plugin.

For me the best part of dired is "do-what-i-mean" mode, dired-dwim. You basically get the output of `ls -la` and edit it as a text file. When you save, dired figures out changed names/permission bits/etc and does what you mean to those files.

I agree, it is a good example, and hey I learned something.

I really appreciate that you're taking the time to respond to all the feedback in this thread and wade through everyone's nitpicks. Looking forward to more articles.

These are all good points, and I wish more clis were like this. My own pet peeve is un-disablable stdout logging.

> It’s important that each row of your output is a single ‘entry’ of data.

It felt weird to me to use `ls` as an example as it's not immediately obvious it adheres to the advice from the printed output. I suppose they were also trying to highlight the earlier point of differing output format depending on whether output is a tty/pipe.

Unrelated, but I didn't know `ls` was that smart about isatty. Once upon a time I read the '-1' option to print one name per line in the man page and assumed it was necessary for that functionality. Thanks!

> distribution and syncing diffs among peers

That's the stated purpose of git. Git syncs diffs, distributedly. The whole point of the article was that we have technology that works and is very well supported, so we should use and improve those rather than reinvent them for the sake of a new technology.

It depends on what you mean by "CS".

If you mean CS in the academic sense, e.g. algorithm research, probably not much.

If you mean CS as in "occupation that involves designing and/implementing software" then I'd argue empathy is an integral part of being an effective professional. Empathy facillitates effective communication and ethical/moral decisions.

I think the idea that "all that matters is your code" is flawed. It's very short-sighted and narrow minded, and it does nothing but to artificially limit oneself. The world is bigger. You interact with other people and can have either a positive or negative effect on them.

I hate to advocate for it, but AWS Cognito is laughably cheap and certainly not going anywhere. Big downside is that there isn't a way to export; you'd have to list all usernames and have every user reset their password. Not really helping with vendor dependency, unfortunately.

It takes a lot of sorting through terrible docs to understand, but user pools are OpenID Connect compliant. You get canned login/mfa/forgot ui's out of the box for every platform, and it's so cheap.

50k MAU with Cognito: free. [1]

50k MAU with Auth0: $850/mo. [2]

[1] https://aws.amazon.com/cognito/pricing/

[2] https://auth0.com/pricing

EDIT: Thinking about this post a bit, it doesn't really address your key concern of vendor lock-in and feels like a shill. My immediate gut reaction was "who cares if you're locked in, no way can you beat the price," and that isn't very constructive. I know on an intellectual level that history has taught us a lot of things about monopolies and entrenched players, but emotionally the visible price tag elicits a strong response. Maybe someday Teddy Roosevelt will rise from his grave and save us all.

I'm not GP, but what drove me towards MT and away from Ubnt was Ubiquiti's history of violating the GPL [1].

[1] https://news.ycombinator.com/item?id=9331512