I think we don’t remember the things because we know they are at the reach of our fingers.
This is based on my experience with driving. I used to drive car every other week from the city where I live to my hometown (230km give or take). I did the route several times for few years - and still I never could remember which exit to take on specific places. Then I decided to drive without navigation. It took few wrong turns and one try and now I remember my route without any problems.
I think it's because it's trite and repetitive and you've done it for 5 different languages and way too many years.
You felt some emotion when you first learned a language and built something cool with it.
You don't feel anything nowadays implementing the 200th service.
~20 years ago I knew most PHP function by heart.
Today I need to keep the rust documentation open.
I had roughly the same internet access I have now.
What you point out with the GPS likely happened because the negative emotion of taking the wrong turn built a memory for you.
I don’t mean for this to sound snarky, it’s an honest question: are there no signs? Having to “remember” which exit to take seems to indicate to me that the route isn’t drivable in any intuitive way (ie follow the signage to your city/block)
Because if there are signs, I just think this depends on how we individually use GPS assistance.
Signs take attention looking at. They often don’t point to where you want to go, but some other major destination along the way, or road names. Junctions can be confusing.
When I can, I like to drive without satnav, it makes me appreciate the geography more.
My hometown is a small one, so I have to remember which (bigger) cities are prior to mine. Also it's not just going on a single highway to reach my destination it's a combination of 2 different highways and several motorways and even roads that lead through villages. There are also often detours because of construction and whatnot.
Maybe important to note, this is Europe. Going from one's country big city to other's country small city. It's not just straight single highway.
If you have 230km trip, it is unlikely there'll be signs at beginning that indicate "turn left to go to specific place X". Similarly when you get to exit highway or turn to downtown, it'll say "Jarvis street exit" or "Exit 238", but if you're going to a random house on a random street in random part of random town, signs really may not be that helpful or specific.
So I may be going to 123 Brown street of Pleasantville, and to get there I need to take number of random roads in my town, get to highway 10, then take ramp to Highway 20 West (which at this point is actually going South, because highways are wiggly but need consistent naming), then take exit 303 "Alabama Street" to go to Atom road to drive 20km to take right on Williams Boulevard to get to town of Pleasantville and take 3 more streets to go to Brown Street.
(also, note that I've found signs in different places be oriented very differently; in parts of Europe, you'll frequently have sings that indicate which way to a selection of big neighbouring cities; I don't really see that in North America)
Seeing the right sign but being three lanes over in nose to tail traffic is a semi-common occurrence when driving for me - missed many exits that way...
> I think we don’t remember the things because we know they are at the reach of our fingers.
To be more precise: studies have shown that passive learning is significantly less effective than active learning[1]. "Active" learning involves intentional recall, as opposed to passive review. Searching things is passive review. Racking your brain to try to remember the prototype of a function is active recall, which significantly strengthens the memory in your brain.
So, yes, this is the reason, and there's scientific evidence to back it up.
I agree, and this isn’t necessarily a bad thing. I have so much random web development knowledge crammed in my head I’m more than happy to offload the rest to devdocs.io and StackOverflow. Although it does mean that I frequently forget which of my projects contains the solution to that one bizarre problem I just ran into again, so whenever I solve one of those I try to leave myself an easily grepable comment.
I actually found it when I was looking for a replacement for Dash, after I switched to Linux. It's not quite as convenient (still miss being able to pull up Dash with a global hotkey) but it gets the job done.
Using Google less for privacy reasons aside (and you should too), I’ve found that as my career has progressed, I find myself way more often reading source code and the base documentation. Or in the case of JavaScript and CSS usually the W3 spec is the clearest source; not only is it straight from the horse’s mouth (more accurate), but it really isn’t overly technical with use cases and examples, and most importantly it displays the types of the inputs and outputs.
I regularly read source. And one of my pet peeves with TypeScript is that I will click on a type and have to walk half a dozen types deep to understand what it is. Because the library has sensibly abstracted types to be DRY and whatnot.
What I want is a type flattener that I can point at a type and it basically links it all so I see a raw type in all its verbose but complete glory.
This is almost exactly TypeScript’s worldview at the type level. It’s just structural types. The only difference is that it’s statically analyzable as a core feature.
JS is a little more complicated than that, but (sorry to tell you) so is ClojureScript, where a “map” can become a bunch of different actual data types through the course of a normal runtime.
In all cases, sending plain maps/pojos is nice but receiving them is fraught. Again TypeScript helps here by providing type guards where your parse/validation code can be statically analyzed.
Edit: and in terms of serialization, all of these languages struggle with fidelity loss. Clojure has EDN or Transit if you’re willing to incur one cost or another. But by default you’re sending out a smaller subset of types than your runtime is using, and receiving the same.
I'm guessing you mean it's similar to the map case?
Clojure/Script of course approaches validation and parsing using schema systems (malli or spec) that has its advantages compared to static type based approaches.
I mean TypeScript’s structural type system is effectively “just use maps”. With very few exceptions, any structurally equivalent type is substitutable for another.
> Clojure/Script of course approaches validation and parsing using schema systems (malli or spec) that has its advantages compared to static type based approaches.
So does TypeScript. It has to, because the type system doesn’t have a runtime. The benefit in TS is that you also get static analysis.
Can you point to some exemplar TS schema system(s) suitable for structured data parsing and validation? I've seen io-ts but it seems quite clunky in comparison, but maybe it's not representative.
Typescript is fundamentally bad for this because the type system does not exist at runtime. I’ve yet to find one I like so I just hand roll both typings and JSON schema. Particularly because I want the schema for other languages too.
Yes, I would have pointed to Zod. There are a lot of options in the space, but I think there’s still room for improvement.
My (vaporware, but I’ve built something similar before on top of io-ts) project would provide a similar API, but with base types built from JSON Schema definitions, and automatically generate docs.
There are also opportunities to significantly improve runtime performance (at the expense of build time) by avoiding unnecessary parsing where statically checked code paths are already valid, eg naive multiple parse steps.
I want a type flattener and function call tree flattener for C++ and Rust, since I use those languages more than JS. Right now I make do by flattening call trees myself in Google Docs, but that's time-consuming.
You can use a merge type (on mobile so this may be wrong, but hopefully gets you on your way to where you’re going):
type Merge<T> = { [K in keyof T]: T[K] }
Typical usage is with intersection types like:
Merge<A & B>
Where the resulting type is not aliased, at least at the top level, and you just see the structure of both A and B. But it should also work for inheritance, interface extensions, and object type overloads.
I think as of either 4.4 or 4.5 you can also safely make it recursive.
I'm a TS dev and only switched in the last month from decades of Eclipse to VS Code. "Peek call hierarchy" is my favorite feature. Granted it doesn't totally flatten an inheritance chain but it saves a ton of time versus going one by one through references.
I think the idea is that, as you get good at spelunking through source code, it becomes faster to find the answer in the source than to do anything else. E.g. I was wondering how division worked in Java, and right after searching for "ArithmeticException" in openjdk I ended up looking at HotSpot's implementation of div. Turns out (based on a source code comment) that it's defined in the JVM spec, but how would I have known that?
Some codebases don't have source available, e.g. Windows, so there I guess one would use the docs.
I agree. With Javascript projects and frameworks, documentation can be extremely hit or miss in a way that I don't experience with other language like Python, Java, or Go.
I still use Google to search the documentation more easily. The Python docs are usually in the top three results if you search for "python typeddict" or whatever.
I always felt the official docs to be quite low in the rankings. For some reason python always has tons of tutorials for every possible situation, and those seem to bury the docs. Also the official docs are some too verbose and still don't have the detail I'm after.
Maybe my second point is the reason for the first.
I often end up getting results only applicable to python 2. I really dislike that they changed the language so much without ensuring backwards compatibility or changing the name.
Add "Python 3" (in quotes) to your google queries. In short time Google will figure it out and start sending you to Python 3 tutorials and docs.
In fact, I think that's the default now. Google may have associated you with Python 2, but I'm getting almost all Python 3 results for any search Python related.
You can also filter by time, but that's less useful because Python 2.7 pushed the end of life date so far back.
My biggest gripe about technology in general is getting used to how something works, and then, for no reason at all (apparently) it just gets changed.
Google does this because a team wants to make a name so they do a retool or redesign, it is a line item on a budget sheet and a metric for bonuses or whatever.
Users be damned.
I've taken to freezing certain servers and never updating them just to fight back against this. I'm tired of breaking changes every few weeks. I'm tired of learning where an option was hid in this update, only to have it moved in the next one, and the next.
As an industry, shame should be wielded to prevent this. Microsoft was never held accountable for their transgressions with excel and Word. It really opened the gates for every other development house to do the same thing, and now, a decade and a half later...
For me it's the exact opposite. Documentation - especially auto-generated one - immediately makes me feel lost. I don't know where to start and when I just read it by itself my brain shuts off within minutes. The only way I can use documentation is by using it as reference alongside a project I'm working on, that's why examples are one of the most important factors for me.
But I also have to say - better no examples than misleading, outdated ones. And please for dog's sake don't link to a site that requires registering an account to read nothing more than "further example" code snippets that turn out to be the same outdated examples with different variable names.
Right but I used to feel the same way. After years of programming, raw api spec and documentation started making sense. And I found that the answers I needed were more often than not in there
I've been gravitating toward Sourcegraph a lot more in leu of documentation. You really can't do much better than finding real life examples of how some library is used.
> I find myself way more often reading source code and the base documentation.
Yes, search engine results are for amateurs (except for finding the source, spec, base documentation, etc.). If you are serious, hold yourself and your learning to higher standards.
It's also faster to read the serious sources: They are much more dense and complete, requiring less searching around and accumulation of stuff, much more to the point, more authoritative and accurate, and IME more clear (I think because clear writing requires deep understanding and clear thinking, which is much more likely to be had by the dev who wrote the code or the experts writing the spec, than blogs, reddit, or even HN commenters).
You'll find that most of the online forum/blog authors don't actually know what they are talking about (and that many of your peers have big holes or misunderstandings).
I don't think that's accurate. Like the gp, I find myself relying more and more on reading the source and reading specs (WhatWG, RFCs, etc). However, search engine results are still incredibly valuable.
> Yes, search engine results are for amateurs (except for finding the source, spec, base documentation, etc.). If you are serious, hold yourself and your learning to higher standards.
This is exceptionally gatekeepy and predicated on the assumption that everyone learns or consumes knowledge in the same way you do, which is just not true. We already work in a profession that has issues with gatekeeping - I think we should avoid exacerbating that.
> We already work in a profession that has issues with gatekeeping - I think we should avoid exacerbating that.
Why? Law and Medicine are gatekept fields, the minimum bar is essential for providing such sensitive services. With all the security issues - never mind accessibility - I think that professional software development should be gatekept.
Hobbist software development - where many of us started - should of course have welcoming arms to new members. I wonder how the Law and Medicine fields would cope with hobbist communities.
I've done 433 google searches in the past week with about 70-80% of them being coding related.
One of the things that suprised my bootcamp students when I was doing a live demo was how messy actual development looked.
If I've done something before, I'll jump to that bit of code. Copy paste if it's not worth doing a refactoring / it's in a different system.
Straight to google if it's something I don't know.
If I want to check params etc I'll jump into the source with cmd b in pycharm.
If I'm doing too many things that I already know how to do I would be wondering if I'm using my time efficiently.
I really enjoy my teaching of and in R, where it is preferable to develop most commands yourself. Preferable because it is just hard to google even fundamental tasks because it is hard to formulate your problem. You must use Google only strategically.
Then I taught a class on applied software development in Python and I had to learn that convention cannot be developed by just yourself, so most of the times it is indeed "Straight to google if it's something I don't know."
I think for the latter it is the right way to teach the process as messy as it is, but what does that say about it?
And not to be misunderstood: Most of the problems we face in R are harder to google because the user base for what we do is so much smaller.
I'm writing a lot of CI/CD for R and R Shiny apps with various SQL backends for my employer and the broader data science team.
There's so little good documentation out there for R, I've spent weeks in trial and error trying to understand why ODBC connection strings fail and R SQL code is failing. And even more time deciphering why certain R packages in Debian don't work at all.
I've taken the effort to compile a lot of them myself from source (GitHub) and writing the appropriate love letters (aka documentation) for my future self.
Working with R for the first time has been an insanely difficult learning curve for an R language novice. Especially when compared to writing Python where most questions I can't answer immediately are only a search engine away.
After coding professionally for 15+ years I still use GDD (Google-Drive Development).
I was embarrassed by it for a long time and attempted to memorize Git commands, standard libraries, keyboard shortcuts, etc. with little to no long-term success and lots of time invested.
Glad to see others also relying on external knowledge rather than trying to internalize everything.
I do google-driven development too, but I think you should have 90% of git commands you use memorized.
Of course if I need to do something fancy like purge something from history, merge two repos, etc. I'm going to be googling it, but this is fewer than 1% of your regular git commands. If you have to google every time you need to cherry-pick, rebase, amend a commit, etc. (and you do these things frequently like I do) I suspect you're spending a lot more time in google than you need to. I would get at least 10% less done in a day if I was doing this.
That's fine, but these things also add up. If I don't remember most of my 90% actions then I'm effectively operating at 20%.
An example with English (and I suspect many other languages have a similar statistic), is that 75% of communication is limited to a set of the 800 most commonly-used words. If you learn these 800 words you can communicate effectively without having to look things up.
But if you don't have a functional vocabulary and you have to write an essay in English, the essay will take 10 times as long to write; you'll need to consult a reference for almost every word you need to use.
There was a website once where people would (anonymously) admit to things that they should know but don’t. Like a developer admitting they didn’t know basic command line commands and stuff, or a scientist admitting they didn’t understand calculus. Anyone have any memory of what that site was?
It was sort of a site dedicated to imposter syndrome.
Imposter syndrome is when you THINK/FEEL you don't know enough for a particular job role or situation.
What you describe seems to be small instances of ACTUALLY NOT KNOWING a small fact / nugget and needing to look it up (not really devastating but might reinforce one's imposter syndrome).
Nope, imposter syndrome is when you're perfectly capable of doing a job but you don't know everything your role is supposed to know.
You can be a successful scientist in a math-heavy field without having to do any pen and paper calculus ever. But you're supposed to be good at it, hence you feel like an imposter.
Just like when you've been writing code for years and then they tell you're supposed to know how to write algorithms on a white board.
This is incorrect - it's not about lacking bits of knowledge expected for a role, it's when someone feels like a fraud and undeserving of their status despite being entirely competent.
You can be entirely competent for a role and do it successfully while still feeling like you're missing fundamental knowledge you won't ever need to accomplish your job but that it's commonly perceived as a requisite. That can generate anxiety as you believe someone will at some point discover what you perceive as ignorance.
Don't know, I'm still not convinced. The term deals more with the outcome, feeling like a fraud while being perfectly capable of fulfilling a role, than the reasons that could spawn those feelings. In my opinion feeling you lack knowledge you don't really need could be one of those reasons. Another could be you come from a different background than your peers and you feel somewhat inferior for being atypical.
I agree. But imposter syndrome is exacerbated by thinking/feeling that everyone around you knows so much more than you, when in reality they (probably) don’t.
The site was dedicated to breaking down the illusion that everyone around you knows everything, and it is only you that doesn’t understand something.
But this isn't about what you know or don't know. It's about the most expedient way to solve a problem. A lot of times, you might know enough to figure it out within five or ten minutes, but if you Google it, that goes down to 30-60 seconds.
I google a lot in my job as well, but one thing I’m trying to do is reduce the number of repetitive searches I do and remembering what to do afterwards. I think part of personal development is learning how to do something and not relying on google or any other reference because as we’re all aware they’re will be a time when stack overflow or GitHub goes down.
I've been trying to do almost the opposite: as I gain experience, the number of tools that I want to be able to use keeps getting bigger, which makes it unreasonable for me to try to remember the details of how to use any of them.
I make a lot of my own notes ( https://til.simonwillison.net/ ) but I also rely very heavily on Google, and I'm fine with that.
I think a good way of looking at it is like the knowledge circles where everything inside the circle is stuff you don’t google but everything outside is things you do. Over time the circle expands as you learn more but this leads to more things you need to google.
The issue with notes is when the solution changes because of an update. Using Google and grabbing recent solutions gets you updated answers if and when things change.
I try to find the balance between both of these options. I think it’s important to remember that just because someone wrote a blog post recently doesn’t mean it’s better. It also depends what you consider “core” knowledge, as an example I don’t need to google how to rebase anymore but I sure as heck do google something new about git every week.
Sigh... searching is redundant, not guaranteed to be sorted the same, not guaranteed to be up-to-date, and updates are not guaranteed to be correct. your notes will last forever, whether or not the software changes under your feet.
I (try to) take notes, and look around once i see a deprecation warning.
> I google a lot in my job as well, but one thing I’m trying to do is reduce the number of repetitive searches I do and remembering what to do afterwards. I think part of personal development is learning how to do something and not relying on google or any other reference because as we’re all aware they’re will be a time when stack overflow or GitHub goes down.
For me, it really helps to blog with code snippets, annotations and full explanations.
I use git diff > iteration123.patch then copy-paste to OneNote along with a quick summary of my thought process.
It really helps me to retain what I've learned (and it reassures me that I can account for how I'm spending the considerable self-learning time I'm being given during my current internship)
As a beginner in the coding world over the past decade, I have written less than 100 lines of js and fixed or amended even less, created a handwritten website using css, minimal js, and html. I have done some bash scripting and use the terminal in linux quite frequently. I just learned about regex(exciting!).
I was at first shocked to see how vague the searches here were. Then it quickly dawned on me that everything I am trying to do has been done before(basically). Therefore, my searches can be very specific.
It's a simplification, but the difference is probably that as a beginner you're searching "how to do this thing with this lib". The experienced dev is probably searching "how does this lib work", and will figure out "how to do this thing" by themselves once their mental model of the lib is more accurate
> Then it quickly dawned on me that everything I am trying to do has been done before(basically). Therefore, my searches can be very specific.
This works well for the first couple of years, but I've found that beyond that you start getting borderline useless results, because you're tasked with doing things that don't have a precedent (at least not in the framework, language, or business use case you are working with).
I've googled <X> authentication for every frontend framework out there. It's surprisingly pretty tedious to represent a traditional auth flow, especially including JWTs and state management concerns.
Thankfully, most already have an established solution for it. Express (read Node) had Passport.js and NextJS has NextAuth. Not without their flaws, but they will solve 99% of use cases.
My searches are mostly for esoteric error messages that I tweak a dozen times to get Google to stop returning unrelated results. Then I usually give up, get lunch, and the answer comes to me when I sit back down.
I recently got a new job where I build solutions on top of an open source CRM-type product. It's been around for a while and has a good online community but it's still pretty niche, so a Google search isn't nearly as likely to turn up answers to a non-trivial question as reading the source is. My Google search history has always (and still does) look like this on a regular basis.
The whole situation has really made me appreciate search engines, forums and sites like Stack Exchange.
It definitely changed how documentation itself works. I almost never use any built-in docs these days; searching via Google is way likelier to find a hit on what I care about (and more importantly, will often churn up any gotchas in using the API that don't show up in the formal docs).
What upsets me is that used books are now out of sight, I believe because every used book that's out of print can be priced extortionately for the one person in the world who needs it most.
I bought a book in the 1990s that is a classic reference on a certain technical topic, and I could not find equivalent information by Googling, but additionally, a copy of the physical book is priced at hundreds of dollars.
So I'm lucky I did buy it long ago and was able to find it.
Economic theory says this increases collective welfare, but I still feel like it's another dystopian thing from my personal perspective, where technology != progress.
Is there still a way to search within search results?
Too often the ranking wisdom puts tons of "wrong" results on top, and requires result paging ad-infinitum. Some engines even flag such paging as bot behavior....
Nice. As if impostor syndrome is not enough, now also getting labeled as a bot!
That or ten results at the top where the original poster asks "how do I foo the bar", which is what you're doing, but their actual problem is that they're missing a semicolon.
I'm creating a faster search engine of usual programming queries and this article is very helpful. The quick search is performed from a preloaded database in memory, so it takes milliseconds to find and update, no web queries, no page reloading. I started this project because I switch a lot between languages and constantly forget/confuse their syntax, so I wanted it to show me the snippet for that same operation in those different languages instead of doing several searches. Don't want to hijack this thread, but I'd like to know what features you people would expect.
Kind of, but for example if you input "append item to array" in that wiki it will show you a bunch of results that you need to read or even open in order to find the code sample. Which is the usual search engine output. My idea is giving you 1 snippet per language in the result, telling you which lang it's for and you are able to filter out and prioritize them from the UI or query. A quick visual inspection of the results will give you the answer.
A lot of my searches are for errors, using Google I can find answers like "yes package X version 3 will give 6that error on node 10 so fiddle around with version until you get it working since the package maintainer did not backport the fix".
Or I can find similar issues reported and open bug reports with my issue so I know that is not only me with this problem.
Sometimes I forget how to do something in the correct/efficient way, things I only do one time a year at most.
The worst offenders for this are package bundlers. Like when they remove/change features and don't have the decency to leave a note saying what change and how to fix it. There are dozens of issues and StackOverflow questions dedicated to obscure errors that make no sense — if you're lucky to find them. Sometimes even specific errors come out but they don't make any sense. Could anyone add a link to these? No.
> you can do something 100 times but still not remember how to do it off the top of your head
This. I'm one of the creators of https://cogram.com, where we're trying to address this problem, allowing you to get to a solution in your editor right away instead copy-pasting and then adapting something you find online. This may be of interest to folks who use Jupyter Notebook and google a lot of Python syntax -- it essentially brings Copilot-like features to Jupyter Notebook.
You can use it by either writing code (and Cogram will complete it), or by writing comments (in which case Cogram completes the code that matches the comment). We've also launched a web app that generates SQL statements from simple descriptions of what you'd like to achieve. I'd love to hear your feedback if you get a chance to try it out.
This is based on my experience with driving. I used to drive car every other week from the city where I live to my hometown (230km give or take). I did the route several times for few years - and still I never could remember which exit to take on specific places. Then I decided to drive without navigation. It took few wrong turns and one try and now I remember my route without any problems.