Have you rediscovered the joy of programming? Any advice?
Why is programming fun? What delights may its practitioner
expect as his reward?
First is the sheer joy of making things. As the child delights
in his mud pie, so the adult enjoys building things, especially
things of his own design. I think this delight must be an image of
God's delight in making things, a delight shown in the distinctness
and newness of each leaf and each snowflake.
Second is the pleasure of making things that are useful to
other people. Deep within, we want others to use our work and
to find it helpful. In this respect the programming system is not
essentially different from the child's first clay pencil holder ''for Daddy's office."
Third is the fascination of fashioning complex puzzle-like
objects of interlocking moving parts and watching them work in
subtle cycles, playing out the consequences of principles built in
from the beginning. The programmed computer has all the fascination of the pinball machine or the jukebox mechanism, carried
to the ultimate.
Fourth is the joy of always learning, which springs from the
nonrepeating nature of the task. In one way or another the problem is ever new, and its solver learns something: sometimes practical, sometimes theoretical, and sometimes both.
Finally, there is the delight of working in such a tractable
medium. The programmer, like the poet, works only slightly re- moved from pure thought-stuff. He builds his castles in the air,
from air, creating by exertion of the imagination. Few media of
creation are so flexible, so easy to polish and rework, so readily
capable of realizing grand conceptual structures. (As we shall see
later, this very tractability has its own problems.)
...that has nothing to do with the problem in my opinion.
Yes, programming is fun in general but then you come in touch with the reality of the job only to find out once again that
1. you are not making things, most of the time you maintain some old crap because nobody wants to spend time and money on building a new better version etc
2. The thing you are working on is useful but you can't really tell how. The damn thing is so big that all your input after years of work is almost invisible to anyone, even on your team
3. Library here, framework there and most of your own code is just a clever way of putting them together. Fascinating at the beginning, a boring routine a few years later
4. okay, sure, that's enjoyable, sometimes too much.
5. Again - works in theory, breaks after the next meeting. "No time to rework and polish. It works somehow and generates money, so go help those guys finish their work. Bad architecture? Hard to maintain? No matter, management sees only frontend anyway"
My personal projects used to be about the end goal: making something that I want to make but don't get to at work.
Lately they've been more about the exercise: the sheer pleasure of writing code that's my own, that will always be my own, that works well and all lives in my head, even if what it actually does isn't especially new or interesting. It's like a digital zen garden.
I have been working on a large project for over 6 months now, 30k lines of code.....it still feels like I have not done much.
My instinct is that no implementation of a piece of software should ever need to be more complex than the idea of it is (fully and precisely articulated, of course). Yet the code is usually orders of magnitude more complex than that. I don't understand why we can't solve this problem.
The paper also discusses that you can separate a program into
1. state (data that changes over time)
2. behavior (computational logic)
In order to reduce the accidental complexity, you can use functional programming (which is purely behavior, devoid of complexity due to state mutation) for the behavior part. For the state part, you can use a relational database to manage it in a more systematic manner. They call it functional-relational approach to software design.
If you do game development, you likely heard of ECS (entity-component-system) and data oriented programming which in a way promotes this approach to software design.
On the other hand, the "making things that are useful to other people" is not that important to me. I mean, it's nice when the stuff I make is useful to other people, but it's not the primary thing that makes me love programming.
So, I think the thing is that you need to figure out why you loved it in the first place? Is it "joy of learning"? In that case: go find a weird new programming language and dive deep into it (become one of those weirdos that think everything should be made in Haskell or Prolog!). If on the other hand you like making things that other people find useful, go look for open source projects you can contribute to. Think deeply about what it was that made you love programming in the first place, and what parts are missing now that existed back then.
And watching people use my creations to do things they couldn’t before is a reward on its own. I imagine it’s like a teacher watching their students apply their lessons in daily life.
This may sound dismissive or condescending and I promise it isn't my intent: have you considered speaking with an actual therapist? As a society we tend to think of therapists as something you do when you're mentally ill, but you don't just go to the dentist when you suspect you have a cavity: mental hygiene is important, and humans are universally bad at self-diagnosis, either physiological or otherwise.
In my current job I write Python, which I really don't like very much and I get burned out on Python-specific things. But I know my feelings of burnout are due to things that would be true regardless of the technical environment - and that an overall job with Python is far preferable to my previously miserable job with F#. And there's a lot of non-job stuff going on - such as the historic pandemic, and domestic stresses from being cooped up at home.
So speaking with a therapist about what's actually eating you might be quite worthwhile. If it is just burnout with programming, there really are specialists out there who might give well-informed, non-anecdotal advice. If it's something else, then having a professional suss it out means you can make better decisions about major aspects of your life. Plus, therapy is something that's easy to do over videochat. I am not recommending therapy, but I do think you should consider it.
I started seeing a therapist about a year ago and went through a similar mental switch. I used to think of them as, like "mind doctors" to fix you when something is going wrong. But now I realize therapists are much more like personal trainers for your mind.
I'm not mentally ill or suffering any particular crisis and I still get a ton of my therapy appointments. It's basically an hour with a really smart person deeply trained in psychology who helps me make the most out of my particular brain and personality.
I love F#. F# is by far my favorite programming language when it comes to writing enterprise software.
The problem with the F# job was that many on the sales team, and in upper management overall, were just bad people. They were a bad influence on my boss, the CTO and an otherwise good person. I ended up resigning over an ethics dispute.
A simplistic metric like "job listings on angel.co" (especially if you're specifically looking for Rails in the job posting title) don't tell the whole story.
Use the right tool for the job. If "the winner" was all that mattered, we'd all be using Java now, and it would remain the top language forever, as long as it makes any sense at all to use -- not even requiring it to make more sense than other options.
It is less of a problem for mature ecosystem and tools, but being in the "not winner" position will likely induce negative effects in the long term technological progress. (I am sure there are many counterexamples)
Sufficient investment for significant ongoing value is a matter of a threshold relevant to the particular needs served by the target technology, not of rank. As long as there's "enough" interest, it will have as much likelihood of stable or increasing value for (appropriately targeted) users as anything else.
Meanwhile, too much investment from too-big interested parties can ruin something pretty thoroughly.
Things are not as straightforwardly popularity-contest-driven as you seem to suggest.
Popularity contests are not simple.
Programming is an huge field comprising many unsyncronized industries and fields. Each of them can have its own winner (or winners) and they interact in complex ways. How is beyond the point.
My claim is that having the most mindshare/resources is the simplest way to keep having the most mindshare/resources. Few technologies rely only o this to stay alive, but a relevant factor is that differently than many other (often technical) advantages this one has a positive feedback loop.
Coming back to the original topic, this might mean that even if you invest a lot in the "best" tool to solve your problems it is possible that the lack of ecosystem around it (due to other people choosing "worse" tools for the same problems) makes it a losing investment.
Of course things are not linear and even the best interpolations have only intervals of validity, yet general long-term trends and cycles exist.
If you want you can add a rate of decay to the weight of nodes in the model, but the point remain: resource distribution is typically not fair in any a priori sense; often it simply scale with the already available resources.
Example: Bitcoin is the among biggest cryptocoins mostly because it was the biggest at some point.
I did not, in fact, say they were.
> My claim is that having the most mindshare/resources is the simplest way to keep having the most mindshare/resources.
That's largely true. Of course, having "enough" mindshare/resources is plenty, generally; one needn't necessarily have "the most". I don't see Ruby or Rails going away any time soon, even if your local area's angel.co listings show a 40% higher rate of job postings that explicitly mention Django in the headline. Development is still quite active both on, and with, the language and the framework.
> Coming back to the original topic, this might mean that even if you invest a lot in the "best" tool to solve your problems it is possible that the lack of ecosystem around it (due to other people choosing "worse" tools for the same problems) makes it a losing investment.
If your choice is Smalltalk, that might be true. If it's actually a very active community around a language and framework that provide extremely good productivity support and a lot of advanced tooling constantly attracting more innovation and heavily used in some sectors, like Ruby and Rails, it's not so true. There's pretty much guaranteed (absent government-granted monopolies) to be quite a bit of diversity in "popular enough" languages and tools for any high-traffic development sector, and "startups" definitely qualifies as such a sector of development as a field of professional work. The "winner" approach you seem to want to champion would have room for basically two options, and both of them have "Java" in the names of their most popular implementations, so arguing about the relative popularity of a Python framework in one corner of the world is irrelevant at best given your evidently intended thesis.
> Example: Bitcoin is the among biggest cryptocoins mostly because it was the biggest at some point.
This is a good point, but does not address the fact that this doesn't mean discounting Decred or Monero as a terrible choice for any useful timescale is the obvious best option.
Ruby on Rails is more popular in some areas than Django. Ruby on Rails gets a lot of time and money investment. Ruby on Rails is likely to be a good, stable choice for years to come. That example illustrates the fact that always choosing "the winner" doesn't make sense if "the winner" involves choosing the second-worst tool for your specific job out of a field of a dozen or more available tools.
I mean, there are plenty of things I used to like that I don't anymore, should I go see a therapist every time my interests change?
In this case though, I see someone who badly wants to be enjoying programming, but for whatever reason they don't understand they don't. It's probably a good time to talk to someone. Usually I'd start with my girlfriend, maybe my mum, perhaps take a few weeks off and then see how I feel. If that doesn't sort it, I'd probably want to talk to a therapist.
I would recommend reading munificent's comment above about therapists as "mental trainers." I think everyone should consider seeing a therapist at least at some point in their lives. The idea that therapy is only when something is medically wrong is at best misguided and at worst dangerous.
When I suggested OP considers therapy, I didn't mean "uh oh, sounds like you're clinically depressed, DSM-V states that a loss of interest..." And the word "consider" is doing a lot of work there. OP's brain is clearly trying to tell them something, and having a knowledgeable certified professional to talk things through with is simply prudent when it comes to something as profound (and risky) as reconsidering your career.
Changing hobbies is not the same as trying to change what you did for a living for the past decade.
I've met an artist who became a doctor, a lawyer who became a stockbroker, a software developer who became a full-time professional musician, a professor who started a hedge fund, etc.
Then I had another thought: Physics disgusts me a little bit now, but I used to enjoy doing physics. Why did I enjoy it? I used to play with it. [...] So I got this new attitude. Now that I am burned out and I’ll never accomplish anything, I’ve got this nice position at the university teaching classes which I rather enjoy, and just like I read the Arabian Nights for pleasure, I’m going to play with physics, whenever I want to, without worrying about any importance whatsoever.
 Surely You’re Joking, Mr. Feynman!”: Adventures of a Curious Character.
I reached the point where I'd sort my list, look at the things at the top and think, "I know these things are important, and it's certainly gratifying to have the influence and the authority to try to make these changes... but I kind of don't really care."
At that point, I realized that if something didn't change I was eventually going to get fed up and leave the project entirely, leaving a big hole. So, I said that I'd set aside Friday to do some "fun" programming, to keep the job interesting. (I ran this by my boss, and he was supportive.) I thought this "fun" would have to be something really different and new, but it turns out nearly any kind of programming will do; so although I mentally give myself permission to do whatever I want on those days if I need to, I often end up just writing "normal" "important" code from the top of my to-do list. Just that little bit is enough to "pay" for the rest of the week.
Joy is the source of our power as human beings. No human activity is sustainable long-term if the psychological cost of doing something outweighs the psychological benefit; and conversely, people can endure an amazing amount of hardship and toil if the activity is a source of joy. The key to sustainable work, relationships, whatever is to be looking for ways to find joy in those activities.
Time you enjoy wasting is not wasted. I often need to remind myself of that.
I recommend you study different programming paradigms because in them we can find really interesting approaches to solve problems.
For me those have been:
- functional programming (with Haskell)
- logic programming (prolog)
- Constraint Programming with the excellent Coursera class on minizinc.
Those paradigms made programming fun again for me.
It's hard to explain, but no other language has given me such joy in perhaps decades.
If you look back on those times where you just had a booklet and a simple BASIC interpreter or C64 Assembler crafting your tiny little applications and games without third party libraries, distracting ceremony and best-practices anxiety. Those times where you could be so proud of every little achievement because it was truly yours, and that for some reason felt your most productive years... Then you might want to give it a go.
Just don't fall for the trap of developing your own Forth. Even if that's part of the philosophy of it :)
Now I just wished there was a book akin to "Land of Lisp" but in Forth. Maybe one should...
I.e. stop programming for the sake of programming. A new paradigm, language or methodology to be more efficient.
Instead solve problems, and use the tools at hand, my excitement from programming originally was the idea that I could build anything.
Callbacks, then Bluebird, then Promises, then a sync await.
a new testing framework every six months. a new web framework every couple of years. aimless, massive changes to the language (classes in a prototyped language? Why not).
paradigms that make no sense (react morphing from a UI library to the full app). a million ways to manage state.
then you have a few big players calling all the shots (FB, MS). I guess we use functional components now. Eurasia has always been at war with Oceana.
It’s tiring. I’ve spent my entire career doing this stuff; and I’m never quite good enough before The Next Big Thing comes along.
I know things change over time everywhere, but it’s hard to imagine anything moving faster with less purpose than the JS ecosystem.
(Apologies for typos and grammar; I’m on my phone)
Imagine if you were a woodworker making furniture. You make the same furniture every day and love your craft. But every month, someone shows up, takes all your hand tools, and replaces them all with a set that are mostly the same but slightly different and all have completely different names.
But the ecosystem around is just that never ending grind. At my last job, over the 3 or so years I was working fully stack, it was just a constant churn. Start with React / Redux / SRR / Jest / Mocha / (probably some other testing frameworks) / Flow. By the end none of the original testing frameworks were being used. React had introduced Hooks, which I actually like, but it was a whole new paradigm to learn again. Flow was out and we needed to migrate to Typescript as quick as possible. And this is just the React ecosystem!
React has its place and I'm definitely comfortable working with it (also writing 0 tests cause I have no idea where to even start for that) but I'm looking forward to the day maybe simple web apps get back to simple setups. Projects like LiveView for Phoenix really give that hope.
 - https://github.com/phoenixframework/phoenix_live_view
I don't have much time for this cr*p, nor do I like it, so I tend to use olde fashioned JS + libraries like jQuery for old fashioned multi page web apps. I want to learn Blazor and Vue for SPAs to keep it more simple.
As an analogy, consider fiction. Imagine reading as many new novels as possible as they're released. Well, most of these novels will be completely irrelevant 5 years from now. The good ones stand the test of time. So you might as well only read novels that are 5+ years old, yet are still relevant and receive acclaim.
There's no way many in the industry can keep up with all the changes you listed as fast as they're coming out. Therefore, it follows that a great many of your JS developer peers are "behind." Therefore, it's okay for you to be, too.
What happens to me, personally, is I start on some new project or company using a pretty recent stack at the time. Over the course of the next few years, that stack becomes "outdated" as new things are released. However, it also matures as its documentation improves and its community grows. Eventually, after 2-5 years, I move on to another project, and just take that time to catch up on the latest. The result is that I end up skipping a lot of the fads that die on the vine. For example, I largely missed CoffeeScript.
I think a lot of pain from JS comes from the expectation that one can and should keep up, when you probably can't, and definitely shouldn't.
The problem with this is that everyone jumps on new fads so quickly that, if you don't, you're likely to endup with a bug-ridden, half-baked, vulnerability-riddled, unmaintained/abandoned, slowly collapsing, termite-infested framework as the basis of your entire SAAS business, or whatever it is you're trying to run on something that even the creators abandoned for the next fad.
> What happens to me, personally, is I start on some new project or company using a pretty recent stack at the time. Over the course of the next few years, that stack becomes "outdated" as new things are released. However, it also matures as its documentation improves and its community grows.
You have to be very, very lucky to accidentally end up with a "pretty recent stack" that will still be maintained in five years. On the other hand, the next part shows that you don't actually go with the 5+ year old "stood the test of time" tools:
> Eventually, after 2-5 years, I move on to another project, and just take that time to catch up on the latest.
Having to learn a whole new sub-ecosystem in as little as two years is exactly the kind of mind-destroying grind everyone's complaining about. I don't think anyone's just jumping on the newest thing that appears every six months; they're all just having to move to some new toolset every two to five years and burning out ten years into a career because otherwise they'll end up having to be the new maintainers of whatever tools they're using due to the fact nobody else is using them (and thus no one else is maintaining them) any longer.
Learning the interesting stuff, and figuring out new approaches to new problems based on the needs of those problems (and not the whims of the community), is a lot of what makes programming fun for many of us.
Linux exhausts me similarly.
* ALSA; esound; PulseAudio; etc. Just give me updated OSS or sndio on a BSD Unix system. That shit is stable, well-maintained, and not arbitrarily different every few years.
* SysV; upstart; systemd; etc. Just give me BSD RC. Maybe it's not ideal, but shit, it isn't swallowing 80% of userland with eventual ambitions of conquering the kernel and some of the worst defaults I've ever seen.
I'll just stop now, but I could go on for days in this vein. Maybe some of these tools are great, but I don't expect any of them to remain ascendant for more than five years in a form that is effectively recognizable by any significant measure but its name. The churn drives me insane. One of the reasons I aimed for software development in my professional life, abandoning the system and network administration (aka "ops") side of thing, was to escape all that crap. I want to write quality code, build new things and improve existing things, not participate in a rat-race to remain relevant just to have acquired nothing enduring from decades of effort other than stock options and a nice car.
It's also because the JS ecosystem is absolutely massive -- too massive. Instead of consolidating around a good package, people create a new one. You end up with a small number of contributors (often one) per library, and being on the bleeding edge is the only way to make sure your dependencies are maintained.
However, I'm in a position where I have enough autonomy to avoid all that crap and just use the bits I like. When you get minimal and ignore all of the noise about the latest hotness JS libraries, the plain language (not including the lanky browser APIs) is not unpleasant especially over the last few years where some modern syntactic features were added - You can go even further and be selective of the language itself and it can get even more pleasantly minimal, my recent delight has been excluding classes and prototypes as much as possible.
When you take this approach the whole "churn" issue disappears (JS is backwards compatible, you will never have the issues you have with Rust or Elm forcing you to re-write).
I suppose this is the argument many make for C++ which is that, yes it can be a complex nightmare, or (if you are able) you can restrict yourself to a desirable subset and have a happy time. In JS's case, most of the complexity is from "keeping up" with the community and libraries, not the core language itself.
I'm writing a lot of C and Ruby these days, and I love it. I get to learn more about myself as a programmer, instead of more about other programmers as fly-by-night framework developers.
I write my own UI/MVC type code from scratch just because that's the way I roll and my requirements there are a combination of minimal, extremely performance sensitive and in many cases esoteric where I have to write the UI anway so it's not much work compared to forcing existing libraries to do what i want... but if had to I could replace it with some hip and upcoming UI + MVC library and still keep 95% of my core code completely independent and intact.
I think JS world feels like massive churn if 90% of what you are doing is UI UX etc, because that's the interface that can never sit still in the name of progress... either that or you (not you necessarily) are doing it wrong and not separating UI code from your application code (I've seen this happen quite a bit in ye olden angular days where everything becomes attached to angular for no apparent reason, and angular itself is the worst of OOP + MVC where everything is convoluted and difficult to follow).
If you build on others' frameworks, and those frameworks drop out of maintenance because the maintainers moved on to shiny new things, any security vulnerabilities or emerging incompatibilities with browsers can quickly prove ruinous for people who used those frameworks.
I wrote a SPA while working at a consultancy. It was actually pretty churn-proof the way I wrote it, but during one vacation day and the following weekend a couple people (including the boss) just rewrote the whole thing to use more faddish framework stuff. I don't work there any longer, but since then (about 2016) they've probably had to effectively rewrite it twice if they kept up with that approach.
That's what I mean by "constantly impending obsolescence".
I jumped into React early-on (5 years ago), and it's still going strong, and has been for way longer than Angular / Backbone / ExtJs ever did.
I wouldn't say Express is abandoned, I feel it's more that it's "matured". I mean what else can you add / improve?
State management is still an un-settled area; 2 years ago it seemed like Redux was the best choice, but GraphQL / Apollo is eating its lunch. However, when you think about it it still follows a similar conceptual model, but making it even more declarative: You have your "store" (the query result), and you dispatch "actions" to modify that store (the mutations). You just don't have to dispatch an action to fetch data from the server anymore; Apollo handles that for you.
It's true that JS churned very fast for a long time, but I'm seeing signs of it slowing down as problem areas become "settled" one-by-one.
I've been programming professionally for 20 years and doing exclusively frontend with React since about 2014.
After the whole React Hooks thing, I can't freaking wait to do something else; and I'm absolutely livid with their decision to promote Hooks.
They should have forked React instead of introducing that into a somewhat mature ecosystem. Already went through this fractured bullshit with Coffeescript, and a million other frameworks of the moment. The JS community just doesn't learn, and when you see a big player like Facebook making the same mistakes, there really isn't much hope.
My point is, you start to glimpse these overarching patterns as you interact with different takes, and you learn what works and what doesn't, ultimately empowering you to intelligently make tradeoffs or designs of your own. The chaos of web development is, IMO, because it was a new frontier, and a lot of inexperienced leadership occurred. This was compounded by bootcamps churning out people experienced only in Framework X, causing poor re-implementations of nearly _everything else_ inside Framework X.
It sounds like you feel like you _have_ to keep up with these things - perhaps someone else on the team is constantly insisting on migration, but they don't have to go through and tediously migrate and test everything. I'd suspect this lack of autonomy is at the core of your dissatisfaction. You can, and should, say no to a lot of trends, and if you do pick up something new, you should be able to clearly articulate why it's valuable, and these values should be more than superficial.
Another thing worth noting is that the release you work on today is the "legacy, painful" code of tomorrow. But that's a good problem to have - it got the job done. It just happened to get it done in one way, when there are really N ways, and so obviously the numbers game will work against you eventually, even in the imaginary case where the implementation is perfect.
Personally I find no elegance in JS, and writing it feels like a chore. If I had to do that daily I'd want to quit too. Obviously YMMV, but I get no joy in trying to fit the tool to the job, I'd rather just use another tool.
One of the reasons it's so popular is because JS is like Latin. If you know some words from one Latinate language, you could blag your way around half of Europe, probably order a meal and find directions. If you know some JS syntax, you can scrape by using half the tools out there today, and accomplish a bunch of different things.
If you want to go and live somewhere though, it's better to learn the native tongue.
I got into web development, but for me that means mostly back end.
I pretty much dislike big opinionated JS frameworks like Angular, although I have to learn it and I will since I took over a project which uses Angular on front-end.
Sometimes I generate HTML on the server side, when I can, using a bit of old fashioned JS and jQuery where is needed. Sometimes I write a REST API for backend and write the frontend using good old fashioned HTML, CSS, JS and jQuery. I like this two approaches the most.
Now I'm planning to learn Blazor and Vue for SPA development.
I was ready to leave programming for management or other jobs but changed my mind and learning embedded systems, game dev, and some other cool techs. Hoping to transition to robotics or something else soon.
0.1 + 0.2 → 0.30000000000000004
irb(main):001:0> 0.1 + 0.2
Erlang/OTP 22 [erts-10.6.2] [source] [64-bit] [smp:16:16] [ds:16:16:10] [async-threads:1] [hipe]
Interactive Elixir (1.10.2) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> 0.1 + 0.2
Python 2.7.17 (default, Dec 2 2019, 13:23:33)
[GCC 4.2.1 Compatible Apple LLVM 11.0.0 (clang-1184.108.40.206)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 0.1 + 0.2
northrup@Topaz:~/Desktop$ perl -de1
Loading DB routines from perl5db.pl version 1.55
Editor support available.
Enter h or 'h h' for help, or 'man perldebug' for more help.
DB<1> say 0.1 + 0.2
(c) 2008-2019, The CHICKEN Team
(c) 2000-2007, Felix L. Winkelmann
Version 5.1.0 (rev 8e62f718)
linux-unix-gnu-x86-64 [ 64bit dload ptables ]
#;1> (+ 0.1 0.2)
This is SBCL 1.5.8, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.
SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses. See the CREDITS and COPYING files in the
distribution for more information.
* (+ 0.1 0.2)
There are lots of other examples of doing it "right" (using more suitable numeric types) over at https://0.30000000000000004.com/ (alongside a bunch of examples that, to your point, just round, or to the GP's point, just stick to binary floats).
Aside from financial applications, there’s very little reason to care about the trailing remainder.
This is SBCL 1.5.8, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.
SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses. See the CREDITS and COPYING files in the
distribution for more information.
* (= (+ 0.1 0.2) 0.3)
* (= (- (+ 0.1 0.2) 0.3) 0)
"Financial applications" happen to be pretty common reasons for number crunching :)
Internally, they're probably both 0.30000000000000004 (depending on precision), so an equality check returns true.
It could also be that they're both 3/10 rational numbers, but given other tests in this thread that's likely not the case out the box.
This is SBCL 1.5.8, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.
SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses. See the CREDITS and COPYING files in the
distribution for more information.
* (- 0.3 3/10)
* (= (- 0.3 3/10) 0)
* (= (- 3/10 0.3) 0)
* (= 0.3 3/10)
CL-USER(3): (rational (+ 0.1 0.2))
CL-USER(3): (rational 0.3)
sbcl 1.4.16 uses single floats:
I don't know enough about Scheme to dig under the covers to see how it's being represented internally.
The output of inexact numbers is typically truncated. In CHICKEN, you can use flonum-print-precision to tweak that. In an example, straight from the manual:
> (flonum-print-precision 17)
(setf read-default-float-format 'single-float)
(+ 0.1 0.2) => 0.3
(setf read-default-float-format 'double-float)
(+ 0.1 0.2) => 0.30000000000000004
On LispWorks 7.0 I get 0.30000000000000005 for double-float. Hmm.
DB<1> say((0.1+0.2) != 0.3)
I also brought this on when I was a tech lead. Twice a month we would do code katas. Where we would do exercises together in a new language, or library. To continue learning, see if we could do things better.
I ended up in a similar place Functional(ocaml/ML) and multi platform (shared code for back end, mobile, web, and ops).
One of the problems I'm having right now, and is making me want to leave software. I can't find many roles that match that style. My brain hard locks when I try and go back to OOP at this point. I love programming, and working with the community. But right now I feel like I'm banging my head into a wall. Has any one else had this problem?
It also makes my life as an end user miserable on the web on account of the gigantic gobs of program I have to download to make even simple websites work these days, when most could work just as well as a simple HTML page served from a server that didn't somehow manage to spin the fans on my powerful laptop just so it could show me some fancy font and I utterly resent the language, and the developers choice of it for forcing this on me.
People got it wrong when they started writing huge applications in JS.
Just because a language is Turing complete, it doesn't mean it's fitted for everything.
It's like you did your job fine as a carpenter using carpenter's tools and you get a dentist job, but you insist on using carpenter's tools because you already know them.
Interestingly I believe the sendmail config file syntax is Turing complete. You could theoretically create a web app using SMTP as the backend API.
I've had good fun with JS in my own time (where else can you get a GLES window up in 3 lines of code?), and I've written my fair share of helper application that notify me of certain album releases. But I would never ship something using it (and in fact I generally switch to Dart if I get serious enough about a web project, another band-aid solution). It could be preference, or it could be the years of embedded programming expecting timely results with minimum overhead (make no mistake, a modern web browser is a hell of an overhead).
Everywhere somebody built an abstraction to do it.
SDL_Window *window = SDL_CreateWindow("MyApp", 0, 0, 1920, 1080, 0);
And learned Clojure.
You will feel like you know nothing.
You will feel handicapped.
You will be confused.
Then, one day, you will understand what simplicity means
and how Clojure's design embraces that more than in any other language I know.
By then you will have embraced the flying-by-your-pants-exploratory style of programming at the REPL.
And don't want to go back anymore.
It does take me a long time to get there though. It's kicking my arse to be honest. Which is fine, as it means I'm learning - far more enlightening than frustrating.
For anyone who wants to learn Clojure (or any Lisp) from scratch, here's my advice:
Don't try to learn it by reading books. What I mean: don't try to mentally parse and analyze printed code written in Clojure. For uninitiated Clojure code may look like unreadable gibberish. If you try to understand Clojure code by merely staring at it, it may feel very exhausting.
Remember: Unlike most other languages where the code is "dead" until you compile it an run it, Clojure code is a "living thing," analyzing its "static" properties without evaluating that code makes little sense.
Get an editor/IDE that supports "structural editing." Learn basic structural editing commands - slurp, barf, transpose. Learn/set a keybinding that allows you to evaluate the expression at the cursor.
And then eval your expressions and sub-expressions. That would make it much easier to learn. And would bring joy to the experience.
After some time it becomes clear - Lisp is not harder to read. For some people, it's the other way around - going back to languages with C-like syntax may feel awkward.
The problem is I don't have a good track record for completing projects so competitors or collaborators would be greatly appreciated
Side projects are always an option, I guess.
I have gotten burned out of my personal clojure projects same as anything.
It's just a language people. Whether speaking Japanese or English, it's just a language. Yes culture is a part of it, but it doesn't imbue the speaker with some sort of superpower. Yes other languages are fun, but both get the job done. English has the word "love", Japanese has "yugen" but both peoples seem to get by just fine.
In PHP once a function is defined I can't redefine it and then call it again to iteratively build that function
Just because your language has a repl doesn't mean you can get a quick feedback loop from it, in fact the more compile time constructs you have like classes and interfaces the harder it is, particularly if they're sticky with dependencies everywhere
Bret Victor's work I think really illustrates how little respect and investigation we do into feedback loops
No. Most non-lispy (non-homoiconic) languages do not have "true" REPLs (and that includes Python as well). At best they are just that - interactive shells. To understand the distinction, one has to give a sincere heartfelt attempt to use a Lisp. Having able to evaluate any expression and sub-expression without any preceding ceremony is extremely empowering. There's a massive difference in the workflow - any experienced Lisper can attest to that. The benefits of homoiconicity are incredibly underrated in modern programming. Perhaps you just haven't used Lisp for long enough to learn how to appreciate it.
> It's just a language people.
Yes, it is. There are many different ways to express something like "number 42" - using ordinary objects like sticks, or by counting numbers out loud, or by writing the amount using words, or by applying mathematical sigma notation. And Mathematics is just a language as well. And when it comes to expressing something far less trivial than natural numbers, we have not yet discovered|invented better ways.
That all been said - Lisp syntax is not without certain disadvantages. But in many cases - the benefits outweigh the cost. That is why Lisp as an idea is still relevant, even after over six decades. And until we figure out (discover?) a better way, the ideas behind Lisp still would be very useful.
As a 9-5 programmer, I often found myself too mentally exhausted to do any coding outside of work. This meant that over the years, programming became just a job, and nothing more.
But once I changed career tracks, I found that I had the energy to write code after work. It actually felt like taking a break. I went from "I need to get away from the computer and go talk to people" to "I need to get away from people and just write code". And when I was writing code on my own terms, without any project managers or other people telling me what to do, it became fun again.
I'm not necessarily saying you should move into management too. I'm lucky that I enjoy the people side of the job, unlike a lot of programmers. But I think that if you put yourself in the same situation as you were in when you first discovered the joy of programming, you'll be able to rediscover it.
After work it's just reading, films, walks, sports etc for me. I used to get bothered by it seeing other people code and learn tricks, tools, and paradigms at home. Thinking whether I am in the wrong profession, or I am doing it wrong. But now I have accepted it as this is who I am.
I'm in the same boat. I've been coding for over 15 years, and since I've been doing it as a career, I can't bring myself to work on very much outside of work like I used to. I have a github full of projects that I used to work on but when I'm home I want to do something that I enjoy. I don't think I've made a significant commit to any of my projects in over a year. Almost makes me want to go back to being an electrician so I can find renewed passion for what used to be my hobby.
One of the criticisms of management path is that it just blocks your mind with anxieties, since you are dealing with lot of unknowns and things which you don't control ...
If you are truly able to switch off after work (as a manager) and still devote your energy on programming pursuits, then I guess you really have a good team and a really good job.
I would be interested to hear your experiences after you work with good number of teams which you inherit (not build them from scratch), and still feel the same way.
Here's one example that I found that really screws with people not enjoying programming. If you have a career, chances are you're going through rules/bullshit(ie. code standards, needlessly large codebases) made up by other programmers within your organization and that's making you not enjoy programming as much - in contrast to when you were younger and only needed to get things working.
On the bright side, there are ways to handle it. While I don't recommend going YOLO and willfully breaking all the rules or even quitting without a plan, I do recommend trying to find some other outlet/hobby that you enjoy after work hours.
You could also try to contribute to people also trying to make programming less friction-ish.
I'd love to get into the Jai community but really don't know where to start, beyond watching the videos.
I stopped using frameworks, stopped using heavyweight runtimes, switched to a language that built and ran faster, and kicked out everything I didn’t like.
I can now focus on the actual problems I’m trying to solve instead of trying to work out how my problems fit into someone else’s idea of how to do things.
Just my 0.01c. Good luck.
> if you don’t Like something, change it.
This is also super important, and a good point make. Don't ever choose a technology for the sake of looking good; choose something you enjoy working with.
> switched to a language that built and ran faster
Which one did you switch to?
So I compromised by trying Go, and my productivity has been really great. And productivity seems to me to be the thing that is most important about making me happy.
(actually I suspect most people would say they love productivity, but not everyone seems to know how to achieve it).
It can be the feeling of "I know I can do better than this, but I'm not doing better than this right now, so I'm frustrated with myself."
There is no quick easy fix. My only suggestion to you would be to: firstly, accept that this is crap situation to be in, secondly: that it is escapable, and thirdly: realize that to escape you have to return to your roots, and rebuild from there.
When you first discovered programming, it was fun and what you created only mattered you. You started here, so go back here. Do an ancient Advent of Code (https://adventofcode.com/), or the first few Euler Problems (https://projecteuler.net/). Do not share your solutions with anyone. The most important thing is that what you do is not important to anyone except yourself. This is your baseline.
I picked up a C++ codebase for a DCC app plug-in from around 2011 and started porting it to C++17.
At that time I had already started learning Rust. Three months into the project the DCC host app changed API which meant major refactoring on top of porting.
I decided: screw it – let’s rewrite it in Rust (RIIR).
It has been a most amazing experience.
I haven’t felt like this since I was 14 and started learning C and later (Turbo) C++, when I was 16.
The language and community are amazing. Lots of new material that is outside of my comfort zone. Steep learning curve but with the reward of this warm feeling of learning something new almost daily.
“Writing Rust code feels very wholesome”.
I couldn’t have said it better.
I found that the core reason I temporarily lost my love for programming (or nearly lost it on multiple occasions) was because I was coding all the time and was burning myself out.
The monotony of working as a software developer during the day and then coming home to work during the night on my side projects had left me feeling down when my tasks in work or my projects at home didn't work out the way I had planned. On the flipside, when I did things which I considered to be an achievement at work or at home - I felt better in both environments. Almost like a surge of energy. Work/life balance is, of course, a two sided coin and they both have implications on the other.
I think one really needs to find other creative pursuits besides those which they are inclined to practice on a daily basis. It's fantastic to hone your skills in a particular field however I have personally felt that switching off from time to time and dabbing in completely unrelated work would allow me to recharge. In fact, it would help me think of new ideas as my mind had time to process my thoughts and the work I had completed.
When I 'burnt out' in the past I needed several weeks to rest, read, explore my city & countryside, cook my favourite foods, watch my favourite shows and just take care of me.
In order to avoid burn out, I decided to pick three hobbies: one to make me money, one to keep me in shape, and one to keep me creative. I'm sure I read that somewhere! Some of us do this by default, and there is a lot more to life than those three hobbies.. all I know is it has helped me to pace myself, to enjoy life a lot more and to achieve my goals at the same time :)
Delineate between not enjoying your job vs. not enjoying your profession. Sometimes getting a new job in a better work environment and especially with a better manager helps immensely.
Get a new job that is adjacent to software, like technical program management, sales engineer, developer evangelism, etc. Here you can still leverage your extensive programming experience but not have to code. For me - I quickly re-discovered my love for programming.
Treat your employer like your customer. This lets you side-step all the petty office politics, the rat race for the next promotion, etc. which are big contributors to stress-related burnout. Your customer is paying a fair market value for your services - the day that does not hold true, you part ways. No hard feelings.
I think the major difference with this kind of programming is that unlike normal programming, you don't necessarily have a very clear idea at all what your program's output will even look like until after you try it. So there's more of a feeling of "discovery" rather than "invention" and much less of a concrete notion of "correct" and "incorrect" output and it's a pretty different feeling that more "normal" programming.
So for me, what got me passionate about it again was picking up a new language and doing things like projecteuler or leetcode etc. Just trying to solve algorithmic problems with a new language, playing around, learning, improving the code.
Every now and then I need to repeat this cycle. :)
1. First watch the SICP series (https://www.youtube.com/watch?v=-J_xL4IGhJA&list=PLE18841CAB...)
2. Then work through the book (https://mitpress.mit.edu/sites/default/files/sicp/full-text/...)
If you really do the exercises (an hour here and an hour there), you can feel you brain getting wrapped around many core notions in very illuminating ways.
I think it's mostly recommended by people who didn't do all the exercises, or casually browsed through it and all they were left with was the fact that you can write a programming book without mentioning assignments until halfway through or that it's more easy to write a scheme interpreter in scheme than other languages.
But the book is really dense, and you won't be left with much after trying to debug your hundreds line script meant to solve one problem.
* the concept of assignment implying _time_ and messing with the substitution model.
* recursive functions that are iterative
* iterative structures that are recursive
* At the base of the base of the data abstraction in LISP is, well, nothing.
* Code as data, data as code, really strongly underlined.
* The whole LISP written in itself (as a sort of fixed point of a language that defines a language). That is really something.
* The idea of using a language to write a language that lets you express your problem.
That last one is probably obvious to most, but it was really novel to me (despite years of writing functions to compute answers).
I find I get burned out by commercial code. So many hands have touched it, millions of lines, scant docs, hard to make sense of it, but ... deadlines, get this task done and that.
Create a simple program outside of work and connect with the joy again!
I am having fun writing a simple nodejs app which is using AWS service. Nothing groundbreaking but its fun to learn and tinker with. I have no expectation of getting good at AWS or NodeJS, just want to build something and get it working.
I found the opposite was useful. My day job was writing quite trivial code (crud apps, forms, etc) so I started writing far more complex apps in my spare time. Things that were truly challenging. It turns out they're a lot of fun to build.
Best case, you can find pride and joy in something about your programming other than the technical excellence. However, that depends on you personally caring about the purpose of your code's existence.
Of course, left to their own devices, a bunch of engineers could be very happy and ship nothing useful. So you have to impose some sort of balance in a business environment. However, it's an interesting management problem to allow people enough time and autonomy to be proud of their work, while still accomplishing what needs doing. Ideally, with happy engineers, more gets done, and it pays off.
What is the easiest way to launch a simple PHP website these days?
-A simple CRUD web app
-No new sytax to learn (just good ol' PHP)
-Simple flexible front end library (I have used Materialize CSS, is that the best?)
-Any easy way to make the MySQL pieces easier to manage? Any boilerplates?
-Any end to end integrated development environment? I have codeanywhere subscription and inmotion hosting. Is that good?
Essentially I have decent experience with PHP/MySQL from past and want to launch a simple CRUD website using as much off-the-shelf pieces as possible. Looking for the easiest path to get there.
It would be gravy on top of some day I can wrap it into a mobile app (for location, camera etc.)
The hardest hurdle initially is to set up a “virtual environment” which means you have a project by project collection of all the packages you need instead of installing everything globally.
Setting up virtual environments used to be a pain. Today it’s so easy:
1. Make sure you have Python 3.8 installed. There’s installers for Mac and Win.
2. Create a folder for your new project.
2. Inside that folder, use your console or terminal to write: python3 -m venv p_env
3. You now have a virtual env, all your stuff will be stored in that p_env folder.
4. Activate it with another command: source p_env/bin/activate
5. It’s now activated and you can use “pip” to install packages like Django a great web framework.
By the way go check out Django and go through the tutorial. It’s very fun and will get you going with a CRUD in no time.
Composer also provides the benefit of a lot of neat packages that can help accomplish a lot of the heavy lifting, depending on your needs. For my purposes, the Slim Framework was perfect. Beyond that, PHP still has PDO, so I wrote a simple class to manage my common CRUD activities. I haven't bought into the npm-gulp-JS-babel hamster wheel nonsense for the front-end. I still download the odd JS library and FTP upload my files.
Tying it back to the OP, I really rediscovered the joy of programming by ignoring all the over-engineered nonsense that's taken over (particularly in web dev). I stopped feeling like I'm behind if I don't spend a day learning about a process that might save me 20 minutes but will be deprecated in a month and obsolete in a year. I went back to just writing the code that does what I need it to do.
Let's be honest: you don't have any experience with php or mysql anymore. 12 years ago was the era of php 5 with some remnants of 4. Php 7 and the ecosystem are a lot better nowadays (composer, Symfony etc.). For database people tend to use Postgres when they can but even MySQL added lot of good things with JSON, CTE, window functions.
You may want to start learning from scratch.
"Hello world" is still those letters in a .php file uploaded to a host tho.
I think lobste.rs is open source.
Edit: it is. Also I thought it was written in PHP but it turns out to be Rails.
I moved from C++ to the much simpler C which I started to enjoy more because it's not putting such a "mental barrier" between my brain and the problem to solve (another option would've been to use an entirely different programming language you're currently interested in but can't use "at work").
Basically: have one or several fallback projects which are completely different from your usual work, without any self-imposed deadlines or long term planning to go back to when the other work becomes boring or overwhelming, just having fun is the main point, and part of the fun is going back to the core of what makes programming actually fun: Just whipping out code in a way that "feels right" to you, and seeing things actually happen, free from outside opinions or priorities.
From time to time (usually over the Christmas holidays) I take a deep dive into this project, but otherwise it's just a few hours a week at most, usually with months-long pauses inbetween.
PS: it took me a few months to "detox" my brain from the "professional software development process" that has become the norm in the "industry" ("agile" processes, software development patterns, estimates, tickets and all that crap). Those had been deeply ingrained into my brain in the last decades, but it's important to realize that all these things are, in fact, turning programming into a chore where burnout is ineviatable.
We program for various reasons.
We got into it because we loved it then it became our job and what started as something we do for fun became something we do to survive. We no longer have a lot of freedom what we want to program and we are required to code for objectives that doesn't interest us.
On top of that, it becomes something that identifies us and more or less the only tool we have at hand to prove we are successful.
Many start dreaming how can they change the world with this tool and invent the next big thing.
We start attempting to hit jackpots by creating one project after the other and failing miserably in all.
By late 20s mid 30s we get burnt out from failure and many move to management.
The ones that stick are the ones that program for no reason other than they enjoy it and are content with that. They aren't trying to change the world, become super rich etc. Sometimes they do by mere luck but it wasn't their intention.
My suggestion here is to tinker. For example, when was the last time you benchmarked a string comparison function and found out exactly why it bottlenecks down to the cpu instructions, instruction ordering, barriers, caching etc ? It's fun and can suck you in for days and a great learning experience. The example here is specific, but the gist of it is not. I hope it helps you.
I was completely burned out and couldn't stand to code even side projects when I started the hiatus. When I was ready and got back into it again, the passion was 100% back. Still going strong 3 years since.
Later on (still running 5 years later), when I got back into coding again, I got rid of Cratejoy and wrote the backend from scratch in Ruby.
Studying zhuangzi these days.
To be a big bird to float over to a neverland. And to think may be you are a butterfly dreaming of being a man.
To each poison or meat.
As long as he/she enjoys it again, whatsoever.
1. Try something different, new. However, it should not be complex, at least not to start with.
1. If that doesn't hooks you, pick a small trivial, meaningless utility to write in whatever framework you are comfortable with. It is important not to overshoot - really just pick a "meaningless" and simple task.
1. If that doesn't work, pick some small utility from a blog/video where full code is available (many examples here - https://news.ycombinator.com/item?id=16591918). Write whole code again, copying line by line. As you start getting involved, stop copying and start thinking how you would write the next function, or what optimization you'd do for current function, etc.
1. If that also doesn't work, take a break. Don't think about programming at all in that break, that's important.
1. If that doesn't work either, start looking into other roles/domains and what might suit your background and strengths. As I mentioned earlier, may be you are ready for the change :)
What works for me to re-connect with the technology, when once again being close or after to burn-out or in a bad cycle at work is to slow down and 'play' with the technology, and on my own pace.
Years ago I worked in gamedev, so when challenging mental times hit, I sometimes tend to come back and just 'play' a bit with graphics, visualisations, interactive environments, simulations. I am fully aware that I am not going to compare with professional game engines, but it's just to enjoy the creative process, to freely play with ideas; to no care about lines of code / modules that won't pass code review, etc. hence also not being too much restricted by any frameworks if possible. Let the ideas flow once again and let the mind create.
As a side note, not so long ago, I also bought Raspberry Pi with a pretty nice, affordable kit of sensors. Electronics is fun, when apart from creating stuff virtually, you can create it 'outside'. You can touch it, you can hear it (and even can sometimes smell it when burns) and can control stuff writing own simple scripts. Installing Jupyter Hub on Raspberry Pi and playing interactively with sensors and collected data in Python and is just another fun moment, opening further possibilities to explore.
Good luck and, really, try to have fun!
I also would plug !!Con (bangbangcon.com) and StarCon (starcon.io) as conferences specifically about the joy and excitement of computing. Those might be a good source of inspiration for you. (Full disclosure: I help organize !!Con).
I think one of the important things is to find people who do joyful things with computers and spend time with them, or at least follow their work.
I'd also second therapy. Your loss of enjoyment may be a sign of wider issues. At least get it checked out. And you're in the prime age for your "mid-life crisis", which is a real thing that people really go through. Mine was a bastard. Therapy helped.
I may differ in that I'm not really determined to rediscover programming. I have many interests, don't need or want much cash and am quite happy to cobble together income from other sources. But I am curious to probe the extent and permanence of the loss. Learning something new is my approach - Clojure, for the combination of lispy paradigm challenge with practicality (it suits a couple of projects I have in mind). So far I'm enjoying it more than I expected. It's refreshing.
I don't know what the results will be in my case. But learning/discovery is so close to the heart of what attracted many of us to programming, I suggest reconnecting with it as one approach.
If you enjoy making pretty things to show others, then I warmly recommend http://ldjam.com/ - the next game-making contest is this weekend! Join in!
The joy is from taking part. Don't discount yourselves and think you can't enter because you are a beginner. Take part! :D
So basically, take a break from programming and do something else for a bit, and don't sweat the little things that annoy you day-to-day -- try to appreciate instead all the creative freedom and chances you get to really test your intellect.
I.e. some time ago I discovered https://github.com/janestreet/learn-ocaml-workshop and I blasted through the exercises and it was fun :-)
While I have not really lost the love for programming, I've discovered the sheer amount of work one has to do in JS/TS for the smallest payoff. Sure, the languages I'm using for fun might require a lot of study before they can be used effectively (PureScript especially, since it's practically Haskell), the productivity gained is phenomenal.
At work now, I feel like I've got the pedal to the metal but the wheels are spinning the the movement forward is measured in inches per hour, or sometimes per day.
But that's just what every frontend dev job is going to be. There are a few here and there using something better than JS/TS, but not in my area, and they are so few and far between that I probably cannot compete with their other candidates (who, for example, likely have a degree while I do not). So instead of burning out on programming, I've burnt out on the stagnation of the whole market. I'm certainly not the first and of course I will not be the last, but it's really killed my motivation to go further in my career despite still enjoying what I actually do.
I don't want to be a manager, I don't want to run a business, I want to be a programmer.
My main interest is FRP - especially Cycle.js (typescript) RxJS, and GunDB - a js graph database. Also Idris for a couple of years from now. To me these are the tools worth to learn and use but can't find any job with them. :(
What resolved it for me was pretty simple in the end: I joined a company where I really believe in the mission, and I'm surrounded by like-minded people. This has given me a great amount of motivation and reminded me that programming is a superpower. I was simply lost on where to apply this superpower.
Solving important (to me) problems has re-ignited my love of programming, and now even writing yet another piece of CRUD is fun because I believe it will make a difference in the world. I'm looking beyond just the code I'm writing down and thinking about how it helps our users, effective communication, how growth will be affected, how malleable it is, how quickly I can achieve the goal, and so on.
Another thing that helped me was researching other careers. I found a couple of things I think I would get a great deal of satisfaction from. I felt very trapped in a career I hated, and looking at another 30+ years of this was like a dark cloud over me. Giving myself an escape route gave me a lot of clarity and lifted that cloud. I can walk away at any time, if I want to.
I sometimes wish I had gone to school, but for something other than CS. I got into software development with no career at all, there arent a ton of other interesting fields open to uneducated people. If I had gone to school for some other subject I was interested in, i could still have the option of a well-padi software career, but also in something else that fascinates me, as well as opening up a new class of "hybrid jobs" using programming in specialized domains
There are plenty of careers out there that are open to smart but unqualified people though. Once I looked around I realised my options aren't so bad (and some of the options I found may tempt me yet).
Although he was a tyrant boss that I couldn't stand, he taught me what I would need to know to go on and stay focused on the "task at hand" when it came to programming. I started getting into web design and development at the time as well, and made the switch. Been at it ever since.
I used to be a gamer in high school. I'd skip school to stay home and play Asheron's Call. I was so addicted to the game that I was the first to max out on the server of Harvestgain. Had a whole bunch of people come watch the fireworks. It was awesome. Anyways, it was a year after high school and I had been playing that game for 5 years, before realizing that I was just "wasting my life away" playing video games, which is what escalated a push for me to go to college and kind of taught me a valuable lesson: what if I could monetize something I enjoy doing? Programming = being creative, coming up with new ideas, making them a reality, etc.
I work for the media, I freelance for a few companies, started a blog, and started my own business ( https://notetoservices.com ), developing web apps for a variety of different purposes. So I tend to just keep myself busy, coming up with new ideas, and a lot of ideas stem off of other ideas, some free, some monetized. Keeps things... joyful.
The students needed a project to show on their resume so I got together with them to have weekly sprints like a mock engineering team. I taught them good coding practice and slowly built up an engineering team of student engineers during my free time. It helped me rediscover engineering practices and finding open source tools that mirror what I use at work is really eye opening and made me a stronger engineer at work. I understand things with a greater depth.
I don't contribute any code, I just code review, do product planning, and conduct weekly sprints. We try to document a quick summary here: https://github.com/garageScript/c0d3-app/wiki/Sprint-H1-2020
I used to have various side projects and programming passions but as soon as I think about them now my mind just numbs out. All the creative programming energy is going into other things.
So I kinda gave up on trying to hobby program or think of it as something I like to do but as work, and when not working try to do anything that is not involved with it basically. I still wonder if sometimes I could find another small business or job that wouldn't involve programming so I could do it as a hobby again but the money is too good to pass up so not sure what I'll end up doing. I feel like if I could retire I'd soon go back to hobby projects and enjoy it more again. Who knows.
Programming in our youth required one language/framework such as C/UNIX or even Visual BASIC. In contrast, to develop something useful today, you need to learn a different language or framework for the UI, services, DB, security, deployment, and others. Each offers its own universe of packages, tools, procedures for debugging, troubleshooting, and building.
One can certainly persevere and complete a full-stack application with the aid of StackOverflow, Dash, and Google searches, but there is no pleasure in it. The drudgery replaces any sense of gathering speed you feel when you’re proficient and rushing with satisfaction toward your next stopping point — before you realize it’s 5:00am.
My guess is that you keep returning to Hacker News in search of that one-stop language which will offer a hobbyist the old-fashioned combo of proficiency and completeness.
So, I had a Mac and iPhone, some hobby projects I'd dabbled in, and just went all out to learn Macos and iOS development, starting with Objective-c and later swift. I know many here will balk at MacOs, and it is a bit niche, but iOS was really interesting and led to a new job. I think iOS can still offer some challenges that older programmers might enjoy, there's still room for optimising and tweaking perfomance, memory and file size, and it's fun to find out how powerful modern mobiles really are. It's really easy to get started, and you can quickly get to building something really powerful, play around with the AR tools, look at the machine learning. There's good frameworks to get started and powerful stuff like using Metal once you feel like really tweaking things.
In order to actually make that shift I personally was recommended the book "The Artist's Way" by Julia Cameron. If you are anything like me you may experience an intense aversion to something so "artsy", and I 100% understand. BUT I decided that since following that instinct had led me to what I thought was a dreary dead end of bad code forever, I should at least give it a chance, and it was indeed as effective as promised.
Joy is out there, don't lose hope, and good luck!
Look around for a charity that you value, and that you think could make good use of your skills. Local charities often lack people with programming skills, so your contribution might be very valuable to them.
If things go well, you might revisit the old thrill of overcoming unfamiliar challenges. You may take delight in the fact that you are making a difference to something important that goes well beyond you and what you thought was your career. Almost certainly, you'll also make some new friends who can teach you a thing or two, perhaps about things you've never pondered before.
Keep an eye out for someone you can teach. That way, your skills will be magnified, and you may find yourself looking forward to each new day in a way you haven't in a long time.
Another example group might be drones, autopilot systems, and software defined radio.
After my first job of coding w/ databases, I wandered into discrete event modeling for the FAA, building the graphical display of a R&D air traffic control simulation. Next, I built a distributed Unix-based server framework to visualize tactical entities on multilayer map products for combat C^3 simulations. That led to fielding a very large database on a massive parallel supercomputer for gov't intelligence sifting. Then I helped others to use of supercomputers in academia, and finally, I ended up in biomedical image analysis to assess drug development, now involving (deep) machine learning.
So rather than learn how to do the same old thing but switch languages periodically, I opted to learn new problem spaces or employ novel computational models. I can't say such a wandering path was ideal, but here I am still coding in my fourth decade.
Frankly though, I think my next transition is approaching. Maybe it'll be music synthesis or speech recognition or adaptive computer security. It's a big world out there.
I lost my enjoyment for programming. I wrote very little code for about 5 years after burning out. One of my friends wanted to do a joint coding project and he suggested Haskell, so I solved one or two hundred project Euler problems in Haskell. I never got good at Haskell, but I really do enjoy writing smaller projects (less than 5,000 lines of code) in Haskell.
Haskell inspired me to read two fairly easy books on Category Theory. I really enjoyed that also.
I still don't write a lot of code. Every few months, there will be a problem at work that needs my help and then I write the equivalent of 3000 lines of C++. Or, there will be a math problem that I want to solve on the computer. I really enjoy writing those shorter, self-contained programs.
(PS: I started writing code in 1980.)
Try to understand what makes programming unpleasant for you. Is it the language? Is it the framework which you are using? Is it the tools? Is it a particular ecosystem? It's about what you are tasked to do? It's about how the development process at your organization is set up?
Try to change what bothers you. Try to identify what you would like and make a goal reaching that point.
If you end up discovering that you don't like anything about programming, so be it. Maybe it's time for a caree change.
In my previous job I was a game developer and I began to dislike what I did. Now I am a web developer and I enjoy it.
I've had times when I don't feel that I'm enjoying programming, followed by times when I'm really into it, there was this talk called "The Art of Code" that might interest you, the presenter Dylan Beattie shows what I now think is what makes programming interesting, it's about doing things, the programming is the how, not the what
I did start a project for a friend recently and working on a fresh codebase makes it a lot nicer (then I had do import messy data from Excel and it was back to disliking it again).
Around 2011 I started a fresh system for my work and learned Django along the way. That really encouraged me at the time. Everything seemed so well thought through regarding Django and it ramped up my productivity a lot, despite being a new framework and a new language to me.
I think the creative part, designing and coming up with something new helps. Most of jobs hoever are just fixing other peoples crappy code.
Learning and living are really the same thing. Both are just the formation of new synapses in your brain.
Practically speaking, change things up! Maybe find a new job, start a new personal project on something you've never worked on before. Take some time off if necessary and possible. But be sure to fill your time off with as many new experiences as possible.
Also, _passion is a skill_. Sometimes it comes naturally, but it can be cultivated, too. This is called the "growth mindset" (See Carol Dweck's book, "Mindset"). The growth mindset has been extensively studied over the past 3 decades, but only as it relates to intelligence. Now, psychologists are discovering that it applies to passion as well as intelligence.
So what does a growth mindset entail? You can only grow (in passion, intelligence, etc.) if you believe you can grow. So 1) believe that you can cultivate a passion in your career and 2) learn new things.
I had a pretty severe burnout 2 years ago. In my personal experience, the above is how I rediscovered a love for computers.
The first thing is that as a hobby I worked with Go, just on the occasional friday project; it felt quite liberating to work in a fairly low-level, yet productive language, working on projects where quality is not an issue. I did random projects and Advent of Code projects.
The other one was Pico-8, a virtual console with a built-in editing environment. The language is LUA I believe, but since you work inside of the constrained environment, which has a screen of only 128x128 pixels, it's a very low-resolution font with only just over 30 columns wide. The code you write can be hacky and use tons of one- or two-lettered variables, it doesn't really matter; it's your code, nobody will ever collaborate on it, and with the constraints in place you can't ever write more code than you can keep in your head at one time. In theory anyway, I mean if you get ambitious you'll end up minifying your own code to make it all fit.
But anyway I digress; I managed to get a new job where I can work with Go a lot, which is giving me a fresh lease on the developer job. It's also a job where I'm the sole developer (for now), meaning I don't have to fight any political or ego-driven fights (or, much less) to do what I think is right (and in a lot of cases I just have to prove myself I'm right or wrong).
1. Take a break, preferably a long one.
2. Code something that serves no useful purpose. Make it playful.
Personally, when it comes to putting code on the screen I am motivated mostly by two things:
1. I am excited to put a puzzle together. The same thing that makes me interested in finishing a basic puzzle like a sudoku applies to writing code. I want to see my end result work, and putting all the steps together in my code is enough to keep me up late.
2. I am oddly excited about learning and applying best practices. Often I initially solve a problem by mimicking existing patterns. Then I will spend hours pouring over man pages and standard library documentation in order to figure out the best way to do something.
For me, everything else feeds into those two basic motivations. In my career I get to apply those concepts at a larger scale. I'm finding that my motivations extend to domains other than code, both in my career and in my personal life.
I encourage you to reflect and consider the moments when you felt the most joy and the moments when you felt the least joy, and what was different between them.
He then places burnout at the foreign element stage of the Satir Change Model (see, e.g. ): Old status quo - foreign element - chaos - transforming idea - practice - New status quo... with the intent of using your present discomfort to evaluate changes you might want or need to make. If the idea seems helpful, have a look.
 'More Secrets of Consulting: The Consultant's Toolkit', Gerald Weinberg
I had to discover this on my own though. If I were waiting on the corporate world to show me fun and ambitious things I would have long since given up programming in its entirety. Constantly listening to people cry about how hard life is without megabytes of tools and frameworks to do their jobs for them and never having to write original logic, while enjoying all the amenities in the world, is really off putting.
I hate to say it, but I have given up on "enjoying" programming while it is still my career.
I will retire (or change careers) soon enough and will go back to enjoying coding as a hobby again.
In the mean time, I'm trying to enjoy all the fish.
You'd probably enjoy building sand castles by the sea, but wouldn't like working as a construction worker building sky scrapers.
If some of that applies to you, then perhaps the answer is that you should do programming that you enjoy. That could mean doing hobby projects on the side, it could mean trying to start your own business and seeing how that goes, or switching jobs and hoping you get lucky. If programming for 20 years has made you rich, then you could also try living off your savings (and the interest/dividends of what money you invest) and doing some of the above without a 9-5 and seeing how that goes.
Most fun job I've had constantly required me to learn to acquire new problem domain knowledge. Most boring job I've involved technology that was interesting to learn but rather mundane problems to solve and only really stayed somewhat interesting because of boredom driven architectural choices that introduced new technology to the projects to solve the same old problems.
And it's OK if a job isn't super fun for as long as you find something to do in your own time that's stimulating and interesting.
Code reviews, agile “stand up” meetings, sacrificing one of quality or features — all that kills interest, for me. Don’t do those.
I sometimes go months without a fun project. Fortunately, I have one while in quarantine.
A little trial and error aids in discovery.
Initially you won’t know what it is you want to do but you’ll have some sort of curiosity about a project.
You can follow the trail and see where it leads.
Most trails are only five centimeters long. But don’t be discouraged.
When one thread disappears, another often takes its place.
Do this for long enough, protect that sacred time, and you’ll discover some passion.
I don’t doubt programming will find a way to re-emerge again in your life some day (in a pleasant, not tedious way). It encompasses so many fields.
You’ll sort of know when you’re on the right track, because what you love will be oddly peculiar and unlike many other people’s interests. You’ll have trouble explaining why you like doing it (as if it needed justification).
True interests (when properly followed) always looks a little crazy to outsiders.
I think work related programming is the second kind (even if you're working for yourself) and working on projects which you make only for yourself is the first kind.
For me the trick is to not have any expectations (including any secret ones like getting github stars, upvotes, money or any deadlines). Also one thing that took the joy away before was not really programming related (which was always enjoyable) but the regret I felt sinking my time into it not doing anything"productive". Once I let go of the feeling it started becoming fun again.
Effectively programming is like writing or maths - as such it is intrinsically not that interesting to most people, but what you can do with it is.
I.e. most people find books more exciting than grammar, and specific application of math more interesting than just doing calculus disconnected from any practical problem.
While getting started with programming is more difficult than acquiring basic literacy, once you have it, it's not that big of a deal and to grow you need to move onwards (i.e. apply it to real problems or continue studying the theory).
Once you've mastered a certain level of basics, just learning a new language or API is quite pointless unless there is some value proposition tied to it.
But every now and then I discover something new and this is when I get excited again. This is what keep the little coder flame burning that is still left within me.
So I try to find something new every month or two that get's me excited again. Doesn't take much time and is very rewarding.
I mentor people, I architect and manage projects. I lean on communication skills and relationships so that the answer is easy and simple rather than complicated. I do code sometimes, but not the super heavy lifting. It may not work out great in the long term and I might have to take a break, or it might turn out that what I'm doing isn't as valuable somehow, but its working alright thus far.
My fondest programming memories are those aforementioned passion projects, but they're often fleeting. What tends to happen is I go all in on something, write a blog post about it then it kind of drifts away and ultimately I drift too.
It's hard, I'm not sure how to solve it other than saying these feelings come and go - you'll find something/inspiration in the most unexpected places.
When I was a kid programming promised to allow me to make incredible things. It was harder than it looked. I mostly abandoned it as a teenager, and then took it up again in college for the same reason. I've been doing it professionally ever since, for over 15 years.
Personally, the joy of any given task is mostly commensurate with how much effort and frustration is directed at the goal, rather than the technology that is supposed to help me get there. This is a big problem with software, because the medium is so complex, but it applies more generally. If I'm making something in the wood shop, it's one thing to be frustrated because I split the end of a board. It's much more deflating to find out that the power saw is broken.
It's partly practical: if I'm in a wood shop, I have the means to deal with a split board. I often do not have the means or the knowledge to fix the power saw. But just as importantly, it's about my own attitude. What would my 12 year old self do? My only choice was to grab the rusty hand saw, make a wobbly cut, and get on with it. Now that I'm older (I can drive and I have money) I'm more at risk of stopping everything to fix the power tools in the name of quality.
I'm currently working on contract and it has felt like an uphill battle. On reflection, I see that only a small fraction of my time is spent making the software that I was hired to build. The rest goes into fighting with the stack and the business side of the job.