Hacker Newsnew | past | comments | ask | show | jobs | submit | more BiteCode_dev's commentslogin

Currently reading snowden book, "Permanent record". At one point he says that private companies do a huge amount of work for the NSA & Co, and have ridiculous level of access to vast arrays of personal data, which they proceed to give to their employees or subcontractors for processing.

I expect FAANGS to do the same.


All those kind of projects share the same flaw: it uses a DSL instead of an existing language, so tooling/documentation/testing/support/modules are going to be very weak, and 100% depending of the creator for the first years, in a domain that is already a niche.

It could be a library with good API instead. Or even a special env setup for an existing language with injected built-in and automatic imports.

Now you could argue that the goal is to have this "simple DSL that looks like english" so that normal people can use it.

This argument has existed since DSL exist, and the result is always the same:

- the simplicity of the language will, in the end, limits its usefulness. Not every domain is like SQL/HTML/CSS, where descriptive is enough. Complex domains need branches, loop, namespaces, etc. Eventually you will be forced to add features in a twisted way to something that was not designed for it and replace its simplicity with ugliness, or restrain yourself and be limited forever. See Ansible DSL for a good, or rather, horrible, example of that.

- end users that can't use a normal programming language won't suddenly become tech saavy because your DSL is simple, but their use case will never stop at simple. So they will start building complex systems as soon as they use it for real, with a limited DSL and their limited ability. The system will become a monstrosity, and you'll have no tooling to help.

- successful dsl are usually not simple. Css is not. Sql is not. Html is an exception because it has no logic. This has logic.

- it looks so cool. It's like candy for tech lovers. Even to me: I find it so sexy. And so people will adopt it, ignoring the arguments above. Ignoring the decades of such attempts that ended up in pain behind so many corporate firewalls. There will be many tweets at adoption to talk about how nice it is, but no blog post 2 years later to admit it was a bad idea. And then it will happen again with $new_shiny_dsl_based_tool.


All these kinds of HN comments share the same flaw: they unnecessarily detract from the work the OP has done by attacking use cases that the project never claimed to solve.

DSL's, for all their problems, do simplify complex programming logic, and people use them every day to do great things. DSL's like Ansible and Chef save people an order of magnitude of time for server provisioning hence why they are wildly popular.

It seems reasonable to me that someone would build a DSL with the same goals for web browser automation. The screen recording example gif they have looks so intuitive even a non-programmer could do it.

I don't look at this project and expect that it solved every problem with web scraping and reading the README it doesn't look like they are claiming it does either.


All these kinds of HN comments share the same flaw, in failing to recognize that the primary obsession of hacker news is in discussing the flaws of things posted on hacker news.


I would argue that thats the benefit.

I want people more knowledgable than me to comment and point out the flaws in products/reports/theories. Thats what I love about HN.

How critical are those flaws? It's up to you. If you take the approach of "there is no right or wrong, only opinions" when you read comments, it's much better off.


I would argue that trying to find flaws is flawed (atleast in this context). Much better to use a neutral approach where you are equally open to strength and flaws.


Using Ansible is what made me lose faith in DSL's in all the ways mentioned (eventually wanted loops, conditions, variables and namespaces...). Ansible is an API over a domain and if it were originally just represented through a Python language library I don't see why it would be less accessible or productive. Even something as simple as YAML can be screwed up and turned complicated.


Even though I know how to program, I really like Ansible and probably wouldn’t have gotten into it if it had the same functionality but used Python instead of YAML.


Building infrastructure is complicated. Have you found an easier way then Ansible to accomplish building infrastructure?

Ansible does make yaml more complicated, however, you don't need to use much of that complexity for simple projects. Compared to Terraform, Chef, Google Deployment Manager, and Windows Desired State Configuration, Ansible is by far the simplest to get up and running on to do real work with.


AWS CDK would be an example of using a programming language rather than a DSL to build infra.


There's also Pulumi that covers a wider range of infrastructure than AWS only.


Have you tried SaltStack?

It uses YAML too, but always felt much more cleanly composed, and smoothly integrates with scripting languages.

I've never truly broken into orchestration and am still salty about that so please, take my post with a grain of salt.

(Full disclosure: I have literally no professional affiliations whatsoever.)


> Even something as simple as YAML can be screwed up and turned complicated.

Your problem is that you think YAML is simple.


Some of us legitimately believe DSLs are rarely the right choice. We don’t say this to shit on people’s work, we say it to kick off a conversation about API design.

I’ve written DSLs in the past. I was a Rubyist! I have come to some perspective on those choices in the intervening years. I’m a big fan of functions that take arguments, and I am skeptical of hidden shared state.


You can be skeptical of DSL's but still recognize that they provide a time/complexity trade-off. I agree that it's probably not the right decision to write your own DSL for something but to dogmatically crusade against all DSL's feels silly to me when there are so many popular projects using them.

Ansible is popular because it is accessible to devop type roles (previously known as sysadmin or IT services) that may know some programming but would fail to produce results nearly as fast if they were simply left with python libraries. It would not be as popular as it is today if it were simply a python library.

Criticizing this project for using a DSL as it's interface over some programmer purity test BS is completely missing the forest for the trees.


> they provide a time/complexity trade-off

I think that’s too specific of a claim for such a broad category as DSLs.

I think in specific cases there is a time-complexity tradeoff you can exploit, those are the (IMO extremely rare) cases where a DSL is worth considering. But in a lot of cases it’s just added complexity. Functions are pretty powerful.

And they are also easier to reason about. Often the DSL adds “time” because you’re like “why the heck isn’t this working” and it’s because of some weird state you can’t inspect that’s deep inside your parse tree. “Guess I better start reading the source code of my DSL runtime. Oh look, someone hacked a corner care into the parser.”

My rule of thumb would be something like:

1) if you have time to make your DSL superbly executed, and 2) you are very certain it can make an entire class of problems go away, and 3) you don’t expect weird corner cases to ever show up in a future project that break the model ...then it’s worth considering.

As a professional coder though, I don’t see a lot of situations like that. In particular the “build this module superbly” is generally not an option on the table. Nor is “you can model the domain of future needs thoroughly” But I work at startups, I bet at a BigCo if you are a very senior person DSLs are on the table more often.


Your whole argument boils down to "use a DSL only when appropriate" - no argument here on my end.

Still, I don't think that makes a DSL a bad fit for this specific project, even by your own standards.

> 1) if you have time to make your DSL superbly executed, and 2) you are very certain it can make an entire class of problems go away, and 3) you don’t expect weird corner cases to ever show up in a future project that break the model ...then it’s worth considering.

#1 yes, just like any code you write, right?

#2 yep, this is the same thing as complexity/time trade off

#3 maybe? you can still have edge cases that you can't solve with your DSL but that doesn't invalidate its usage if the benefits from #2 are great enough.

And #4, which is the biggest reason and the reason to use it on a project like this: it provides a more accessible interface to your project for a broader audience of people.


I completely agree (not related to this project, but a rant in Ruby). I used to thing metaprograming and DSLs were the best part of Ruby. Now I think it is the worst part. It makes code almost impossible to inspect, has hidden shared state everywhere, and makes things like stack traces end up saying `at line 66 in method_missing`. Or if you can locate the method, it is running it in `instance_eval` making it really hard to know what the state is when it is run. Ruby is actually a very functional language and now if I write Ruby code it is as functional as I can make it.


I tried using Ansible once and could never escape the fact that anything complex like installing files or raising docker containers requires the use of external modules with actual code and templated YAML. Every time something "templated" shows up in a supposedly "declarative" language it feels like the designers had to add on features from an actual programming language to do what they wanted, because the DSL was too declarative and static to accomplish anything useful.

For example, look at this Azure deployment template:

https://github.com/Azure/azure-quickstart-templates/blob/65d...

Notice all the inline function calls. They basically modified JSON with their own domain-specific "functions" like "concat" and have an entire section dedicated to "variables" because in standard JSON this is not possible to express. Already this sounds like a scripting language, except terribly watered down and specific only to Azure services.

As a personal anecdote, I once made the dumb mistake of choosing a static config file instead of a dynamic one when I was developing a mod system for a game. The problem became that there were things like function callbacks that I wanted to add in, so that meant I ended up writing inline "pointers" to a place where a Lua callback existed as an identifier, instead of inlining it as Lua code, then it went through an unnecessary transpilation step to Lua data structures. My mistake was assuming that the DSL was expressive enough for my needs, which included loops, inline function callbacks and code generation, when clearly it was not.

Sometimes the effort people expend to make declarative configs work out are significant. The OpenAge project (an engine rewrite of Age of Empires II) uses a declarative language called nyan[1] which describes the changes of things like unit health or cost. It's entirely custom-made for the engine.

The moment that I realized that declarative configs were not for me was when I realized that this declarative language, which the author wrote an entire PhD thesis over and was specifically designed for the purpose of game modding, would still not be expressive for the things I was envisioning. In the end Lua, a general-purpose language that had existed for decades, was the better choice. There was no need to muck around with writing new languages or munging the declarative data into the shape I wanted - the data could just be output from a script.

On the other hand I understand if having a Turing-complete language for configuration is a bad thing because of security or too much expressiveness that hinders static analysis because of unseen edge cases. It depends on if the "scripting" features are hacks intended to get around the fundamental limitations of DSLs or a deliberately constructed featureset.

Also the reason I became so attached to declarative configs in the first place was the prospect of writing an editor frontend to interactively create new data entries. That's probably the reason Azure went with JSON instead of a programming language - they have a template editor in the web portal for filling in the parameterized variables the config declares. This is probably an ease-of-use tradeoff so people don't need to program to deploy things. As someone who uses scripts as configs, how to properly write an editor for them escapes me. I was thinking of having to parse the scripts into an AST and use heuristics to discover where data is inserted, but of course you can program anything so this won't always work.

Still, in my opinion I would choose something like Lua any day over the nth domain-specific proprietary reimplementation of 2% of JavaScript on top of JSON.

[1] https://github.com/SFTtech/nyan


The whole point of this is the scripting language, there are already lots of other browser automation tools out there.


A scripting language is not a goal in itself (although in the case of a DSL, it often is unfortunately because of the coolness factor), solving a problem is.

Here the problems it tries to solve are:

1 - to have a nicer API to do automation

2 - for non tech saavy users to be able to create tests

My take on this is that DSL are a wrong answer to this.

1 can be solved with a better lib, with a better API, or a dedicated env.

2 is probably not solvable: automatic testing it hard, you need to be tech saavy to do it.

But let's say you still want to solve 2, a better approach would be to solve 1, then solve 2 by creating a GUI that let users record their actions and generate code from 1.

Such API and GUI exist, as you said, but they could be improved by tenfold.

It's boring work though, and working on a DSL is much more cool.


> A scripting language is not a goal in itself

Agreed, I think this is a case where people forget “what is the problem I’m trying to solve” and instead get lost in a means not an ends.


Depends if the goal was to make a scripting language and at the same time tackle a problem (or not). Some people like building stuff for the hell of it. A language by itself is an interesting non-trivial project.


I actually kind of really like this DSL, I think it is going to be easier for my QA team to use this, than asking them to use javascript.


Seriously, how is this DSL better? With JavaScript you get method completion and debugging. Are parentheses really so terrible?

You can setup a DSL in scala.js and you can get the best of both worlds (though, parentheses are fine for me so I would just use one of the many fine existing JS libraries).


> With JavaScript you get method completion and debugging.

a) now your QA team needs to know JavaScript

b) method completion is crap when you don't know the language.

c) "You can setup a DSL in scala.js and you can get the best of both worlds" OMG You want to add Scala to the mix too? AND write your own DSL from scratch, and take on its maintenance to support your QA team's needs instead of leveraging an existing one?

your solution:

1. teach the QA team Javascript interaction with custom scala created dsl

2. have the dev team spend time creating a dsl

3. have the dev team devote some of its resources to maintaining the new DSL

their solution:

1. use english-like DSL much easier to learn than JS

2. that is already created

3. that someone else maintains

both solutions are going to have limitations in that what you want the DSL to do will be more than the DSL can _currently_ do.


The other choice is that your QA teams knows this DSL tho. Which is the point: eventually most DSLs converge on the complexity of programming languages and you’re left asking: why not just use a well known programming language in the first place?

We’ve beat the Ansible example to death but it’s a really good one. It started as something simple and then with every edge case came the need for increasingly complex logic until it resembled a programming language just with super funky syntax.


a-c) I didn't mean that QA or whoever learn Javascript or scala.js. (though I'm not as scared by the idea as others)

The library authors can use those the create a better DSL (or as I call it: "just a good API"). the cognitive load on the users is the same, only it's easier to setup up proper tooling

in javascript you can make the exact sample api he defined only with `await` and some parentheses

in scala you can setup API that looks like: `browser show page`, users don't really learn scala just write the same commands they otherwise would (I'm not saying you should do this. You could, if you really hate parentheses for some reason, but there is a way about it without inventing your own ecosystem)


1) if you are on a qa team writing automation, there is a high chance you already know javascript.

source: was qa automation engineer for a few years. I realize it is purely anecdotal, but nearly all of the QA people I worked with knew javascript, even the manual testers.


My experience here is different. The majority of manual QA I've worked with do not have experience with automation, nor do they know JavaScript.


I know right. It looks so nice. I want to pet it.

But it's a trap.


These are actually valid points for any DSL creation. I have been working on DSL for a few years. More precisely I'm working on a DSL tool that allows people to create "simple DSL that looks like english" so that normal people can use it. Here are my thoughts on those arguments.

Indeed complexity is there for most real domains. But DSL is meant to be another abstraction layer on top of the complexity. My lesson is constraint is the most important as this lays the foundation of its usefulness. I don't mean you should not have things like branch or loop. You certainly could add them, just in a domain friendly way that doesn't hurt the readability and writability of your DSL.

In order to tackle arbitrary complexity, the DSL itself should be designed with extensibility in mind so that technical people could easily add language constructs or vocabularies by using script or general purpose language. Further, those features should be able to be turned off for some scenarios. For those inherently complex stuff, they should be left to general purpose language anyway.

Tooling support is another big problem. In my opinion, DSL is never just the tiny language, it is about the language and tooling. However the tooling requirement is often not as standard as general purpose language. Domain users normally don't need an IDE(an editor should be generally required) or debugger. Rather, they want something that can be seamlessly integrated with the host application.

And more over, different people (even in the same domain) may have different requirements on DSL maintenance, eg, governance, versioning. This often leads to a case by case customization. I do not have a good answer for this other than the general advice: treat DSL and tooling as a whole and make the API as easy as possible for integration.

Edit: For anyone interested in my DSL(still work in progress), here is a glimpse:

http://www.typezoo.com/docs/workflowrules/editor-2.gif


Absolutely the current version seems very limiting, but as they start adding more and more features towards Turing completeness, it will become just as complex as a normal Turing complete programming language. Which in many ways undermines the original promise.


There is a HUGE difference:

- not all sites use CDN, even if using the same font

- not all sites use the same CDN

- users clear the cache (clearing history does that on firefox)

- incognito mode is a thing

- first load matters a lot

- browser have a limit of the disk space they use for cache, and they evict older entries when they reach it. Given sites are now bloated, this fills up fast.

- this repeats for each browser. I have 5 on my laptop, 3 on my mobile, 2 on my tablet.


Do you think it's still used for the latter rather than the former now?


Heh, that's a better question. I have no reason to believe that Google Fonts are being used to track users, but I don't have hard evidence on this either way. I am deeply concerned about the way the modern Internet is turning into a surveillance machine and its potential for abuse, but if I were evil, I'd probably go after much lower hanging fruit than fonts.


Thanks for this honest answer.


either way, loading fonts from google for every website is a stupid idea... it is why an extension like decentraleyes is a good idea (because most website don't think about the consequences).


I think Google might have better ways to track people. Fonts are also cached by CDNs and the local browser so I’m not sure if they provide good tracking data (they get loaded only for the first page visit for example and popular fonts like Open Sans are probably already in your cache when you open a page).

If you’re concerned about tracking as a website operator you can simply load the fonts from your own server, most of them can be found on Github and have liberal licenses (I think all fonts on fonts.google.com)


You can even install the fonts locally to your machine and your browser will favor the local copy. There are some tools like Skyfonts that let you install the top X from Google Fonts and it can be a fun way to speed up a lot of the web; with the tradeoff that not a lot of people have the top X installed for useful large versions of X and that becomes its own fingerprint for surveillance software (testing how long text takes to render in an off screen canvas, for instance).

It's been suggested that Browsers or Operating Systems choose a useful X value and install the top fonts everywhere like they used to install the classic "core web fonts".


Also there's a addon called "decentraleyes" that will cache fonts, amongst other things. It's one of 3 extensions I install in every browser I'm allowed to. The others are uBlock origin and https everywhere. All 3 have good privacy/security/performance benefits with effectively no breakage, in their default configurations.


Decentraleyes is an excellent add-on that improves browsing speed and privacy with no negative side effects. Currently, the only font cached by Decentraleyes is Noto Sans. It also caches Google's Web Font Loader script and many major JavaScript frameworks.

https://decentraleyes.org

https://git.synz.io/Synzvato/decentraleyes

Web developers who are concerned about privacy exposure from Google Fonts can use google-webfonts-helper to extract the font files and self-host them.

https://google-webfonts-helper.herokuapp.com/fonts

https://github.com/majodev/google-webfonts-helper


Correction: Decentraleyes doesn't actually cache any fonts. Noto Sans is just used for the add-on interface. Font caching would make an interesting feature if the add-on developer is willing to implement it, especially if it bypasses fingerprinting.


I stand corrected!


> You can even install the fonts locally to your machine and your browser will favor the local copy.

Note that some browsers are going in the opposite direction and actively hiding installed fonts from websites due to the potential for fingerprinting.


Delivery of fonts aren't what's used to track people. Rendering of fonts is.

Different machines render fonts in a unique way. Consider different GPUs (hardware differences), different drivers (kernel/driver differences), browsers (user-land differences), and sizes (user settings) can all contribute to a font being rendered differently per-user and increasing entropy of a particular unique font id.


I am slightly concerned, yes. This is why I chose to host the fonts for my 20-things.com sideproject for as long as I can afford that luxury.


I work with a F500 oil company from time to time.

Half of the devs from there that I was in contact with were not capable of:

- googling a solution to a problem efficiently. When they hit a wall, they turned to me with an empty look like they were lost.

- read an error message to troubleshoot. A stack trace is utter mystery.

- use effectively the UI of their laptop. Some can't even Ctrl + S to save, they look up the "save" entry in the menu.

We are talking about people writing code every day, in several programming languages: fortran, c, c++, java, Python...

Because I'm a freelancer, I don't care. I'm paid extremely well to be very nice to them and solve all their problems.

But I'm very glad I don't have to be held responsible for anything those people end up putting in production. And I have no reason to believe it's different in their security department.

However, and this is a good lesson to all of the geeks like me that think work is about doing the right thing: the output they produce is good enough in our society. Its cost/value hits the sweat spot. Business is not about doing things right, it's about being profitable.

If you have one scandal a year, but it costs you less than making sure you have a secure system, and you are not legally challenged, then you are golden.

In fact, the chances to have even one scandal are very low. Actual risks of failure or attack are low. And consequences in case of crisis are low too. People don't care that much about privacy, cyber-security, etc. And policy makers won't enforce their laws anyway, at least not to any extent that will endanger the company.

So if the software allows people to do their job IRL at a reasonable price, under an acceptable deadline, good enough.

In fact, David Goodenough is a very funny French meme: https://www.youtube.com/watch?v=ho4W5LnFl6s


> Because I'm a freelancer, I don't care.

I'm also a freelancer, and I've also said exactly this. I was happy to profit handsomely from the incompetence and apathy of my clients.

But in recent years I realized I was wrong. It doesn't matter how well it pays, I feel like I'm wasting precious chunks of a very limited lifetime being a disciplined and methodical janitor for my clients.

Now it's more important to learn, to stretch, or to contribute to a more worthy cause than just getting paid well to do shitwork.

Time well spent is worth far more than anyone will pay for it.

The unintended side effect of prioritizing learning over invoicing is that revenue now seems to take care of itself. It's all a bit Zen.


From an ethical perspective (also a freelancer), I think it's my job to warn my clients when I think a particular idea won't work and help guide them to either abandon it or find a better idea. It is, after all, why they hired an expert -- presumably I know more about the specialty than they do so why wouldn't they expect that their money is paying for my honest advice?

If the insist on doing it the way they want, I am happy to admit that they may well know more about the business than me and do it anyway. But I'd rather have a reputation for steering my clients in good directions with both advice and direct technical help. That way people will be confident I'm not trying to take them for a ride. Plus better technical specs out of it and clarity around what needs to be done.


Sure, but we are passed the stage of "idea that won't work". The whole system runs in degraded mode at this point.

The best one can do is be patient, and help them do with what they got.


I see it the other way around:

- to them, I'm helpful. So I feel useful, because I got actual humans that are thankful that I'm here. I need that to live, to be happy.

- the money allows me to have a very good life style, so I can enjoy many things I couldn't otherwise in what you call my "very limited lifetime"

- high rates mean less hours, which mean I get to spend time with people I love, have fun and contribute to open source projects.

It's not perfect, sure. But it's pretty sweat.


Alternatively: It's time to up your bill rate.


I did that recently and was astonished that it got accepted so easily. I merely got a "hum..." from some of my clients.

I wish people would have told me that years ago.


Every year, up your rate little-by-little.

One extreme example is there is this homeless guy who is a retired very good teacher who has a way of both teaching kids and correcting problematic behaviors. Unfortunately, he doesn't advertise and he doesn't up his rate ($20/hr IIRC). It's a shame.


I hear you and would like to agree with you.

Unfortunately, for me, being a do-gooder didn't pay very well.

I often wonder if I should have stayed in the rat race during my most productive years and then used that nest egg to fund my activism.

I honestly don't know.


I used to work with a brilliant chip designer who couldn't find the start button on a Windows machine. We all suck at something. Personally, I think CSS is the devil and should we should nuke it from orbit.


True, I have a Ph.D. and am very skilled with electronics and embedded programming. If you handed me an iPhone I would have no idea how to read text messages (actual situation).

Same with the people I help technically at work. They're all brilliant scientists. They get confused by the difference between VGA, DisplayPort, HDMI, and DVI. Or get extremely frustrated when a button on the UI moves.

I think software developers don't quite understand how big a deal it is to a 70 year old when the button to do something moves. Probably a quarter of my day is often just figuring out how to reconfigure things to their liking or else spend an hour retraining them because of some unnecessary UI change in Windows 10, after which they will still forget and ask for help again.

God forbid you break apart an application into multiple programs or have online activation or a license server. I think I hear at least a daily rant about how you can't just buy software anymore and now you can only rent it for a bit.

We have versions of software that are 13 years old because the publisher switched from an unlimited permanent license to a per-seat per-year license model. Rarely worth it when the instructors get confused by new software anyway.


> They get confused by the difference between VGA, DisplayPort, HDMI, and DVI

Back when there were RS232 (aka 9 pin) connectors on PCs, my dad's computer had two mail connectors, one CGA and one serial port (I think it was a serial port, but I'm not sure, as those connectors were usually female). I took the VGA cable and accidentally plugged it into the serial port. When I turned on the computer, I heard the startup chirping noises, the screen was black for a few seconds, and then white smoke started pouring out of the power supply. I turned it off REAL fast :) Somehow the computer still worked after that.

EDIT: changed VGA to CGA


VGA is DE-15 (3 rows), DE-9 (erroneously called DB-9) is 2 rows. ;) Interestingly, VGA only really needs 6 pins to operate: R G B VSYNC HSYNC & GND, and monochrome only needs 4.

I don't see how that's possible without really crushing it in there. Also, CGA & EGA were the same connector as serial (DE-9), which would've been easier to confuse.

It could've been worse: I knew a guy in high-school who plugged a parallel printer into a Mac classic's SCSI DB-25 (the same physical connector as a parallel port, female on the computer; DB-25 serial is a male connector on a PC) and baked it into "apple pie" with that "lovely" magic smoke aroma.


Yup, you are right, it was CGA. Fixed.


"I think software developers don't quite understand how big a deal it is to a 70 year old when the button to do something moves."

My 84 yo mother was technically competent. Currently has mid-stage dementia. Long term recall still remains impressive. Apparently unable to learn new skills, habits.

Every software update is cleaving a few more things from her life.

My siblings and I thought upgrading her to an iPhone was a good idea, some years ago. Initially, sure. But now I wish we had a snapshot of her tech stack from her early 70s, and found a way to keep that working.


My mother, over 90, uses the exact same arrangement which I set up in the mid 90s. Linux, mutt, emacs, fvwm customized to be very simple. Whenever hardware stops working I just need to transfer the setup to a new machine and everything remains identical.

It would've been impossible to do this with commercial software as basically nothing has a 25+ year old support life. Because everything is open source, nothing needs to change.


What? You can’t click on the messages icon? Can you use android? I mean, they are the same.


Yes, I use android all the time. I didn't understand how to switch between applications.


I feel the same. A friend of mine asked me to take a photo with his iPhone XR a while ago. I couldn't figure out how to launch the camera app from the lockscreen.

The gesture controls Apple implemented starting with the iPhone X are also very confusing for an Android user, eve though I also use gesture controls on my S10.

But in the end, you'd get used to it as you did with Android.


Interestingly, Google's implementation of app switching on Android looks somewhat similar to Apple's…


It might. But the Android phone manufacturers tend to build their own interpretation of the stock Android features. The main factor that confused me on the iPhone was the lack of a back button like I'm used to on my Galaxy.


True. And I'm sure most devs that I mention in my comment actually get the job done. In their own way.

I have paired up with some terrible programmers, with bad coding habits, weak knowledge of their ecosystem and no capacity for any kind of architecture design, but that eventually did better than me because they worked way more, and were more persistent.

This idea that bad code will waste productivity is not that important if one person accepts to work 30 hours more than you every week, including to fix the mistakes they introduced by writing said code in the first place.


The level of complexity involved in developing even a basic CRUD solution these days requires knowing a tech stack going from DAL over networking, protocols to Front-end. Just getting all that shit to work and being able to reason through to get something working requires years of experience.

If you can produce something working that satisfies the requirements you can't be terrible in my book, no matter what I think of your style


Something that works & satisfies requirements may still be terrible to maintain, expand or debug. That's the real difference between a well / badly developed app.

Agreed on the levels of complexity in basic apps nowadays.


Let's start a css-less tech trend, shall we? :)


All my websites are built with Unity targeting WebGL! /s


What is this black magic? Serious question.


Unity and WebGL is pretty common now days. You'll find a good chunk of the games at https://itch.io/games/html5 use exactly that.


Unity supports builds targeting WebGL and WASM.

Last time I stumbled on an "io game" built this way, the lack of WASM debugging tools made it very hard to hack at the game :(


I like CSS, can we start with JS first instead?


I wonder if anyone's tried to write a language primarily for manipulating the DOM that's less... "quirky" than JavaScript? With WebAssembly being fairly well supported these days I suppose someone with a background in language design could write an interpreter in C for such a domain-specific language and target WASM.

Of course, people would say "what's the point" when JS is a thing and widely supported. I wonder if there'd be a) a compelling improvement in performance and b) a compelling improvement in reliability if we just wholesale replaced it based on lessons learned? I reckon even just keeping JS and eliminating implicit coercions would be a huge improvement (as well as maybe automatic semicolon insertion) and reduce the debugging times considerably.


> I wonder if anyone's tried to write a language primarily for manipulating the DOM that's less... "quirky" than JavaScript?

I don't know about "less quirky", but Microsoft tried with VBScript. Google tried with Dart. Initially, Dart meant to be interpreted by the browser (not transpiled to JS). I'm sure there might have been similar, smaller projects, but Javascript-in-the-browser has momentum that's hard to beat.


WASM cannot access the DOM. Not yet, anyway. I find this ridiculous, but that's the situation.


Does Elm count?


https://morg.systems/

I'm trying my best :D


    <link rel='stylesheet' href='res/lettercrap.css' />
    <link rel='stylesheet' href='res/style.css' />
;o


> Personally, I think CSS is the devil and should we should nuke it from orbit.

In all my personal projects I just copy-paste past CSS from existing projects of mine to new ones, at most just changing two or three colors.


Yeah, had a college professor that hunt & pecked on the keyboard. He was smart and good at teaching, just terrible at typing.


What? Move back to HTML 3.2?


Yes. Style with inline tags, you're generating your HTML anyway. Use tag names describe what they do rather than "semantic" tags that aren't. Rather than agonising over which polyfills you need to get flexbox support, do table-based layouts that render reliably and quickly in any browser. People went crazy for the <video> tag in HTML5, but <embed> achieves the same result and a nicer UX to boot. What's not to like?


Let's just go ahead and just render each page as one big imagemap


Just the opposite. Imagemaps suck because the user can't resize their browser and have the page reflow appropriately. Too many modern styled websites view that as desirable feature.


More likely is we get one <canvas> tag and everything is powered by an opaque blob of WebAssembly


As for regex...


> - read an error message to trouble shot. A stack trace is utter mystery.

The number of developers I've worked with who handle broken builds with "The build is broken! Why did you break it?" instead of "I shall now proceed to read the error message which will helpfully tell me precisely why the build is broken and how to fix it" has always astounded me.

I've yet to find a way to handle error messages that will actually convince devs to read them. All I've found to date is apologizing for an unclear error message and offering to help with anything they had trouble understanding.


As someone who was part of the small team that used to do our company’s builds before I automated them, I deliberately would not bother reading stack traces and try to fix it but would send it back immediately to the dev.

1. It took too much of my time. Since I was doing this in addition to my dev duties, it was not something I could afford to spend time on. 2. When I first started, I would resolve the issues myself. But I soon realized the builds were usually broken by the same suspects. Sending it back to the devs (and also requiring them to buy a box of donuts on breaking the build) put a quick stop to this. 3. Builds were usually broken by people checking in their code in a hurry right before they were done for the day. Calling them and having them fix it after work (as opposed to me having to sit additional hours after work fixing something they broke) very quickly put an end to the practice of checking in your code in a hurry and leaving for the day because you had a dinner to make it to. I don’t want you to miss your dinner, but if it’s important enough that you can’t be bothered to make sure your code is working then you can also wait till the next morning to checkin your code.


As a developer, 2 and 3 are basicly feedback. If you check in hurry and no one ever tells you it caused a problem, you will slowly unconsciously start believing yourself a god. I never cause a problem with this!

Except I do. And as with anything, feedback takes you back to reality.

Plus you learn where you tend to make mistakes and thus have a chance to study a bit more about area to learn how to not make mistakes.


Doesn't the development happen on a different branch? Of course I push before I go home: if my machine breaks i want to lose a few hours, not a day of work as well.


It took me by surprise too, but now when I give a training, I make sure I include how to:

- read a stack trace

- find things in the doc

- use the debugger

Most people, professional devs, signing up for my __advanced__, yes, specifically requested to be advanced, Python trainings, don't know how to do this.

Again, I try to be extremely nice about this, because nobody likes to feel inadequate and I'd rather have people learning happily this and improve their life and work.

It takes a lot of courage, if you are 40 and being in the field for 2 decades to admit you need to go back to this.

But it's not what I was expecting from the industry.

Hey, it makes me feel useful :)


Given that Python belches stack traces anytime you look at it funny, I can't understand how that could be...


Hey man, I * scrolls back 6 pages * love a good stack trace.


Good that there is a stack recursion limit in Python.


I see you too forgot a comma once in a Java program.


Template compilation errors in C++ were at least 300kb last time I've tried to use that language.


I've gotten my fair share of those from use of Boost.


My guess would be that a lot of coding is autodidactic, aka there is a lot of self-learning, trial and error, etc. This means you learn a lot of bad habits, or develop gaps that a formal training course would avoid.

So when you get to something that is complicated and has the potential for deep strategies and shortcuts for efficiency (e.g debugging), it's no surprise that experienced coders might want a refresher.

Impostor Syndrome may be a thing there, too.


Just today a junior on my team (who is also new to my team) complained to me that a set of docker containers he was trying to spin up were "not coming up." I probed him a bit, he sent me a screenshot. I shit you not, "ERROR: Write /some/path/on/disk: no space left on device." It's pretty incredible. You can lead a horse to water, and all of that.


That seems like the kind of oversight one expects from a junior dev just joining a team, that's where ones job as a senior dev to push them through the process comes in.


Yup. First question - "what do the logs say?"


My favorite is support people that send you a nicely truncated stack trace with all the useful information missing.

E.g only "java.lang.NullPointerException", only the top of the stack, missing "cause" etc. :D


The number of developers I've worked with who handle broken builds with "The build is broken! Why did you break it?"

You have it easy, the devs here in Cardiff push code that doesn’t even compile locally, then start howling that “Jenkins is down!” when the build fails. Or even just “the server is down” with no other details. Like I just telepathically know which of our 5000 VMs is “the”.


As someone outside the software development industry, but with experience programming for various reasons... I'm dumbfounded by this. Is this the result of hiring code bootcamp graduates instead of those with bonafied CS degrees or what?


Don't see how an academic background would help you avoid this it's a skill you're far more likely to learn through practical experience. I don't see bootcampers as being particularly vulnerable to these gaps in knowledge.

My experience in learning computing in school was going through large months long projects where later stages built on early stages but the entire project was throughly documented and paint by Numbers so long as you followed the directions exactly. If you came up with a valid but undocumented solution you would break the assumptions of the documentation and forever be hacking the program to get it to work which was still possible just time consuming and nobody knew how to help you. The end result is students who can follow docs without fucking up but who also don't know how to fix things other than by rolling back to a known good version.

I've found these sorts of problems to be very difficult to solve in academics due to the need to standardize assignments and grading yet a few months doing an original project will infuse you with troubleshooting mojo.


Completely not my experience at Georgia Tech. You were left to your own devices, had to learn sensible debugging and logging in order to complete most tasks in a time efficient manner, and your time was crunched. It probably depends, but I don't see how you can get that experience in a web dev bootcamp


> Don't see how an academic background would help you avoid this it's a skill you're far more likely to learn through practical experience. I don't see bootcampers as being particularly vulnerable to these gaps in knowledge.

Agreed. I was told, and later had to tell others something to the effect of "okay, so what did the error message say? did you search that?"


Another reality check is that fixing build I broke is typically quick while fixing build broken by somebody else takes a lot of time. Those errors are rarely as exact ad to allow you to fix issue in 5 minutes. Occasionally, stack trace leads to quick null pointer fix, but it is tricky as real cause can be deeper (null should not even happen) and quick fix is just hiding larger problem.

Moreover, having person who made bug is just good practice. Feedback, basically. When people know about own errors and have to fix them, they learn more about errors they make.


That's a bad bias you have. I could handle coredumps before I started CS. Also CS does not teach you efficient programming - that's a different course.


I'm actually generally in favor of boot camps since I myself have a self taught CS background with a civil engineering degree, and I actually know quite a lot of computer science. However, there's something to be said for the additional time in and critical thinking that you might get from a CS degree. However, some people on here seem to be indicating that their degree didn't made allowances for struggling through things or was "too academic" in nature.

It perplexes me that you could get through a 4 year degree without learning how to read a compiler error message though. I'd be less perplexed at this happening in a super condensed and streamlined boot camp though.


My experience: through the whole masters degree I had to write ~6 working programs. Only 2 were of non-trivial size. (a compiler and pseudo-physics stimulation) Some were group effort where someone else could easily pick up the debugging if needed. My 5 year degree definitely didn't care about debugging and I think people could do it with next to no programming skills.


I don't know, I'm self-taught and I know how to read stack traces and use a debugger.


Probably because no one was spoon feeding you or holding your hand. Plus the fact that people who can teach themselves are probably a little more driven or competent to start with.


I would guess autodidactic learners are more likely to pick this up than those who mainly learn through formal education. I don't think stack traces or debuggers were ever really covered in my CS program.

Then again, neither was version control...


Then again neither were the languages you were expected to do your homework in. I think there was one "Pascal language" class no one in the Major took. The faculty cared about the Computer Science (Math) underpinnings; the language dejour was just a speed bump to help separate the wheat from the chaff.


My program had a pretty good layout as far as languages. I think the standard was 1.5 classes of C, 1.5 classes of Java, then pretty much everything after was in one of those languages.

Only time I felt students got shafted was a Web Dev elective. People who weren't already pretty experienced with JS had a really hard time (we were on the quarter system, an HTML/CSS/JS+React/Redux+Node is pretty ridiculous to cover in one quarter).


No it's human nature. Do people write code that will make error messages meaningful or not? That's something you see in type and variable names, filenames, warning hygenics, etc.

If the expected cost of decoding the error messages includes a lot of reverse engineering of crap code, people won't bother.

It was a major, major issue in early C++ template metaprogramming. You couldn't give good names to some of your constraints so the errors were nightmares.


That's a curious insinuation. If anything I would expect boot camp grads to be overly dependent on Google.


The oil and gas developers I worked with who were some of the most incompetent people I've ever known had fancy masters degrees (at a minimum) in computer science.


Those skills are not taught in CS degree programs (nor should they be).


It's not so much that they'd be directly taught in a CS program, but more that I'm surprised you'd never have bothered to pick up that skill set, even accidentally during a four year degree.


Apart from comedic value, blame doesn't fix anything.

I resisted joining a startup that exited for 8-figures because one of the devs was emotional/blame-oriented and another one of the devs, a female, was too into me.


Two stories stand out to me, from people who were in the upper ranges of competence where I worked at the time.

1) She didn't know what MD5 was. Had never heard of it. 2) He attended a meeting, seemed to keep up then emailed notes talking about 'Jason encoding'.

I thought these are pretty general concepts to anyone even in passing, you should probably know they exist at least? But maybe I'm in a bubble.


I'd guess a huge % of engineers don't know what MD5 is. It doesn't exactly come up that often outside of being "some random string that is on download pages now and then."

Heck I know what it is and I've only used it a few times outside of copy/pasting stuff w/o needing to think about the underlying details too much.


It's one of the reason I favor framework over libs or micro-framework, espacially from beginner.

E.G: I tell beginners to use django, not flask.

Because people usually don't have the skill or knowledge to take proper design decisions. They need something to guide them, otherwise the project architecture will be terribly wrong.

Last year I worked on a flask site were the devs stored the password hashed as unsalted md5. And another one with an API that returned sometimes JSON, sometime plain text. And this year one that, to be deployed, required you to run a build process on the prod server, and defined the upload folder and static media folder as the same.

My take on this is: if you want to go the minimalist route, you need to be very good already.


> Because I'm a freelancer, I don't care.

I think it goes deeper than just not caring.

I too have spent the last 25+ years working as a contract developer and in my earlier years I would say I did care.

However, as time has passed I've come to realize caring can cause tension which then becomes problematic.

In most case people (i.e. higher management, fellow developers etc) really don't like too being reminded that they are doing things wrong.

My current approach is to raise an issue once, raise that same issue a second time but on the third attempt, bite my tongue and just leave it at that.


> My current approach is to raise an issue once, raise that same issue a second time but on the third attempt, bite my tongue and just leave it at that.

The same thing goes for when you aren't a contract worker and management has slightly different (but not necessarily invalid) opinions on what the right thing is. Depending on your point of view, that and what you said are exactly the same thing with a different lens applied. That is, the "right thing" as viewed from the angle of engineering best practices may or may not be the same as the "right thing" for getting some product out the door, even if many of us wish it was.


I should have said "I don't mind".

My English still needs work.

I actually care. Especially about people and how they feel at work. In kinda why I do this job: it's so easy to make their day better.


> My English still needs work.

I had no trouble with your original post.

However, in my reply I tried to convey the fact that over time my level of care had diminished.

There was a time when I did care.

However after decades working in this industry I can honestly say my level of caring has been beaten down to a minimum.

My impression was your post was reflective of the start of that process.


“the work they produce is good enough in our society”

Gah. I wish I could rebut this but I’m not sure I can. How does one find work for a tech/IT company that actually embrace quality?


This isn't an IT thing. The vast majority of people are average. Anyone who thinks they do better than the rest is likely wrong. It requires insane levels of bureaucratic power and will to truly force anything better than average.

Every single business is full of people who are adequate. From the line staff all the way up to managers. Cynical people call it the peter principle, but it might just be that an average manager is only averagely good at judging who is good at their job and therefore average people are just as likely to get promoted.


> This isn't an IT thing. The vast majority of people are average. Anyone who thinks they do better than the rest is likely wrong. It requires insane levels of bureaucratic power and will to truly force anything better than average.

Or work in a smaller company.


Why do you think smaller companies aren't also full of average people?


The point is that smaller companies are less full of _people_. Less bureaucracy, less institutional inertia and more relative influence of each individual.


Yeah, if someone’s not getting with the program it’s easier to walk across the building and talk to them than email across 3+ time zones and potentially a language barrier.


It's not an IT thing.

Google was a superpower in 2001. I started working in Enterprise IT then and people thought that I had miraculous powers.

Today, it's a crutch and almost anywhere you look, people are searching for random stuff to throw on the wall to see what sticks.


seems like a decent approach. Care expounding?


It's action over reflexion, showing "fast results" over "good results"


You can blame most of it on SEO. Minimally, it's about making sure what you've created is accurately represented. Maximally, it's about tricking people into thinking you're what they want when you aren't. The way that happens is through worse search results.


It's enough to be obedient, not too curious, not having too much self-esteem, and be able to cope with doing crap work (and knowing it) because... well, management doesn't understand the interest of quality

(sorry, too cynical... but I'm in the field for more than 20 years)


it doesn't exist

I suppose you could start your own company but then you will ultimately have to choose to ship and eat or perfect and starve


Perfect is not a must, but good quality would be nice at least.


but "good quality" is subjective which is why it seems like finding a firm that focuses on "good quality" is so difficult


Looks at Apple as it was a few years back


I'm curious, too. It's sad to be the only one even using proper commit messages.


I hear ya :-/


What work are you interested in? Will email you if we match up.


Good degree from good university?


Does that really help in that regard?


I didn't mean it seriously.. I have neither but embrace best practices at work.


Opposite.


Networking is always a center of awesomeness in those companies. I've seen things like six (at least) layers of NAT for "extra security" or super fast fiber optics that are unused because someone left everything hanging off a backup cable line months ago and forgot. In the latter case it was discovered after they spent weeks tweaking QoS settings to make it go faster to no avail.


Not to mention the proxy settings nobody knows how to setup for their particular IDE/cmdlinetool/browser and that blocks the one thing you need to access.


You do care, you solve their problems.

You don’t just try to solve ALL the problems of the organization, which you were not hired to do.

If you were actually tasked to do that, you would want much more compensation.


Yes, bad choice of word, I should have said "don't mind".


I disagree that you are golden if you only have one scandal every few years. You can have zero scandals and still be screwed. If a company has its valuable IP stolen and is then undercut by competitors that never had to spend on R&D it can be a significant loss of revenue.

I also disagree that the risk of an attack is low. An F500 company is the sort of target that can end up in the sights of many different threat actors.


And yet IRL it doesn't happen.

Halifax never paid the price for badly handling their data after all.


Consulting has been a golden lesson for me, because that is the usual scenario in any Fortune 500 whose main business isn't selling software.

Whatever people talk around here, Reddit or random conference is unheard at these companies.

Most devs just punch cards and are happy to know just enough to get going.

Talking about best practices is a lost battle, unless there is someone from above pushing them.


> Business is not about doing things right, it's about being profitable.

Because everybody seems to just read past this and think "oh yeah, yeah that is how things are", I'm gonna say it: That is terrible.

I mean, it's your business whatever you decide to do, but I disapprove.

What gave you the idea that it's ever okay to decisively not do the right thing? Especially when the reason is money. Sorry but if your reasoning is "I'm not doing the right thing but that's okay because it is profitable" then you are actively ruining the world. You get no respect from me for that.



That's a great article, thanks for sharing!


> Business is not about doing things right, it's about being profitable

I find this line particularly insightful. It was the biggest lesson I learned in my transition from academia to industry. No one cared that my work was correct and on time, they cared that the vendor we used caused us to miss the deadline and because I was in charge of the overall system, it was still my fault. A tough lesson, but a good one.


Not sure if that was an intentional mistype of "sweat spot", but given your description of their competence level I read that as a word play on sweating due to the nervousness of their code being ready to blow up vs. "sweet spot" meaning the good balance between cost and value.

Very clever :)


> read an error message to troubleshoot

okay going to play devil's advocate on this one and say that some error messages could be improved. that's all.


Of course, they are a UI too. It's not antagoniste to the OP.


I was one of those techies.

I was wrong.

It was one of the things that completly changed my perspective of computing.

That, and teaching, and working on a streaming website.

I suddenly saw apple products differently. Linux differently. I started to design things from the UI instead of the data model.

And eventually, it lead to accepting many of my limitations in other area, because I took in consideration users limitarions in my area of expertise.

Funny how being wrong can be good for you.


Correct, but it's the same with alternatives.

E.g: redux uses a react provider to inject the data into the component tree because of this. Vuex does the same for vue.


No it isn’t.

React will simply render the object you give it. That means that React doesn’t need to know when data changes, it simply renders the ui, diffs it to the current ui and applys the changes.

Unless your using component state but even then, it’s the rendering that measures change. The act of updating the state just lets React know “time to see if anything important changed”. Vue seems to tra Co data changes granularly which means it needs to understand the change at the point if mutation. This means it needs control of the data you want to render.


Untrue. Using Mobx your model can be defined completely independently from your view layer like React.


I believe backward compat is a goal of vue 3.

In all honesty, the pitfalls are not that many, easy to understand, learn and avoid or get out from.

I spent way more time trying to figure out doing even basic things in react than debugging reactivity in vue. Espacially since the later has a fantastic doc and a small api.


You can use other frameworks the way you use vue but it's not advertised much.

E.G: I teach reactjs by first starting with a simple script tag like you can do with vue. No webpack. No JSX. Suddenly students get it. No magic. It just makes sense.

But this approach is not common nor first class citizen.

What I like with vue is that the authors understand the value of scaling up, as well as scaling __down__. You can feel it in the doc, the API, the community...

So yes, all in all, vuejs will be lighter to use, not because the others can't be, but because it doesn't judge you for wanting to.


i am not a frontend person but i had tried multiple times to learn react and angular. every time, i became frustrated in the tooling phase and gave up. like... geez, i'm having this much trouble already and i haven't even learned the first thing about syntax or reactivity.

then i learned vue, and was able to build something in an afternoon. and, at the end of the afternoon, i had the tooling too. but the vue learning path doesn't teach tooling until after you get a feel for why and how vue can solve your problems.

how it is taught is 100% of the reason vue found a place in my life. HUGE missed opportunity by the other frameworks, which are so eager to prove that they have the bells and whistles that they trip over their own feet trying to get people started.

had i learned from you rather than from docs, i would be using react in my personal projects and never would have looked at vue.


Principle #1 is too extreme.

While I confirm that writing is a powerful medium for thinking, anybody writer with a shower to take or a hike to walk will tell you that thinking takes place in many ways.

Parts like "If you want to learn and remember something long-term, you have to write it down" depends so much of context. Again, writing down does help me to commit things in memory, but for some information, audio is better. For others, repeating in my head is better.

Good advice all in all, but the definitive tone of the article is not needed IMO.


There is this tendency to reduce everything to simple rules that are simply wrong. Nuance takes more effort to put into words and to understand. And so we end up with these 'soundbite' bits of wisdom that are worse than nothing at all.

Writing something down requires clarity, and clarity can be gained in many ways. Writing something down that isn't clear yet will result in (hopefully) spotting that lack of clarity before you press 'send' or 'publish'. But that doesn't mean that all for stuff that ends up written is happening while writing it down and without a very good idea of what you are trying to communicate beforehand you'll end up with bad writing.


This is an interesting point because it could help explain why scientists enjoy programming, even when we sometimes do it to our own detriment. Nothing clarifies a quantitative thought process better than having to write it down in the form of code. And the code either runs or it doesn't, so you know that at least it has some level of self consistency before you walk away from it.


> While I confirm that writing is a powerful medium for thinking, anybody writer with a shower to take or a hike to walk will tell you that thinking takes place in many ways.

This is an article about note taking, not taking showers or going on hikes, or thinking in general, so I think trying to interpret its points outside that context is unreasonable. I think you’re imposing an unreasonably literal an exclusive interpretation of the point. The author doesn’t say it’s the _only_ medium.

On definitive tone, would the article really be clearer if it constantly went off on digressions about non-note taking contexts to every single point? I see criticisms of articles like this here all the time and it’s really tiresome. If every article linked here was full of caveats and digressions on every last point, they would be unreadable. I’ll take a succinct, opinionated expression of someone’s experience and point of view over a rambling exploration of every last facet of a topic any time.


> The author doesn’t say it’s the _only_ medium.

No, but the author does say:

"Completing these tasks is exceedingly difficult inside the confines of our heads. We need an external medium in which to perform this elaboration, and writing is the most effective and convenient one ever invented."


Which is not even close to saying that writing is the only medium, and in fact confirms that there are other mediums to think, including just keeping stuff in your head.


We reason symbolically and in an alphabetic culture such as our its entirely forgivable to name paper and the scribbles you put on it in order to think 'writing'.

Keeping stuff in your head while thinking with the stuff in your head changes it. The same with memories. If you have not noticed this, please challenge the statement: Keeping stuff in your head does not work; you need to externalize in order to use your differential engine, aka brain in order to 'think.'

Having said all this, I think because I am. not the other way 'round! everything else that you may think is thinking, maybe emotional/felt or aesthetic judging, would come from deeper down the stack.

Anyway, tell me about these other media.. and show me how you're not driving complex symbolic insights with them!

its all reasoning by analogy for us anyway :)


Agreed, I think I'd just change a single word:

> Principle #1: Writing is not the outcome of thinking; it is a medium in which thinking takes place

"the medium" → "a medium". It's still a powerful statement.


I come in peace, but look, say I'm exploring things in martial arts. Then I'm only listening to the kinesthetic domain, sinking into it if you will by dismissing ratio in order to learn through another mode.

I can learn like that, without any thinking at all!

We can only learn anchored in feedback, and if you can give yourself the feedback while writing, talking out loud alone, or better yet, with a listener, then you get feedback that keeps you thinking.

Verbalization and conversation maybe media, but writing, coding, sketching definitely are places where I notice my thinking.. What other 'media' did you have in mind?


I feel a tension that I'll lose an idea unless I write it down. After it is written down, I'm able to work with it in a relxaed manner.

I think recording it with audio might be ok too, because you won't lose the idea. But the next step after that is to work with it, and audio doesn't easily give you immediate playback.

With writing there's sort of a feedback loop where you look at what you wrote and turn it over and figure out what's wrong with it and rewrite it or expound on it.

That said, it's your call on "lists of 10 things" because there are some trite internet ones, and some 10-commandment ones.


You should first read the actual explanation of the first principle. It is not what you've understood it as.


I can’t help but wonder if perhaps the helpfulness of a lot of these principles is different for people who can or cannot see/hear in their mind.

https://news.ycombinator.com/item?id=19618927


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: