Everything I googled in a week as a professional software engineer (2019)
localghost.dev
localghost.dev
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 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.
And I’m someone that can walk around randomly and perfectly keep a mental map of the whole area.
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.
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)
~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.
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.
Some codebases don't have source available, e.g. Windows, so there I guess one would use the docs.
Maybe my second point is the reason for the first.
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.
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...
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.
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.
Example - HttpServletRequest
getAsyncContext, getAttribute, getAttributeNames,
getCharacterEncoding, getContentLength,
getContentType, getDispatcherType, getInputStream,
getLocalAddr, getLocale, getLocales, getLocalName,
getLocalPort, getParameter, getParameterMap,
getParameterNames, getParameterValues, getProtocol,
getReader, getRealPath, getRemoteAddr, getRemoteHost,
getRemotePort, getRequestDispatcher, getScheme,
getServerName, getServerPort, getServletContext,
isAsyncStarted, isAsyncSupported, isSecure,
removeAttribute, setAttribute, setCharacterEncoding,
startAsync, startAsync...
getHeader, getHeaderNames, getHeaders, getIntHeader...
In Clojure, Just Use Maps
{:remote-addr "127.0.0.1",
:scheme :http,
:query-params {"somekey" "somevalue"},
:form-params {},
:request-method :get,
:query-string "somekey=somevalue",
:content-type nil,
:uri "/foobaz",
:server-name "localhost",
:params {"somekey" "somevalue"},
:headers
{"accept-encoding" "gzip, deflate",
"connection" "close",
"user-agent" "Apache-HttpClient/4.1.2 (java 1.5)",
"content-length" "0",
"host" "localhost:8383"},
:content-length 0,
:server-port 8383,
:character-encoding nil}
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.
Clojure/Script of course approaches validation and parsing using schema systems (malli or spec) that has its advantages compared to static type based approaches.
> 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.
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.
type Merge<T> = { [K in keyof T]: T[K] }
Merge<A & B>
I think as of either 4.4 or 4.5 you can also safely make it recursive.
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.
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.
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.
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.
Showing them that it’s a messy process with few perfect answers is probably one of the best things you could do for them.
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.
R has been difficult, but definitely rewarding.
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).
Feels slightly different?
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.
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.
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.
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.
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 (try to) take notes, and look around once i see a deprecation warning.
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)
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.
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.
The whole situation has really made me appreciate search engines, forums and sites like Stack Exchange.
I wonder how much search has dramatically changed productivity.
Their quality going down the drain is often quite literally painful.
Gonna need to adapt. Well, already did with my own notes and garbage dumps like Reddit, but it's not enough.
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.
Edit: clearly I should have googled this
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!
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.
This is a good idea for a post. Thank you for posting.
How much could/would they charge?
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.