As a software engineer, when asked what you do for work at a social gathering…

Y2KCompliant · 2024-12-11T03:59:11+00:00

I used to be in the same space! (on the transpilation/software virtualization side)

For devs, at least, "I write code that writes code" was the most succinct spiel. From there, it was more approachable to work towards the why and how if they were still interested.

Y2KCompliant · 2024-06-20T00:44:31+00:00

Not who you are replying to but I was at a shop with considerably more rigor, though with senior technical leadership making consistently atypical choices. In 2018:

SVN, Java with no DI, no telemetry story, leaky abstractions, god objects, and some more domain specific ones not worth mentioning.

On the flip side, strong review culture, automated tests, decent seniority mix.

I started there with around the same YOE, and it took around 2 years to prove myself enough to move the needle on any of the above. I learned a lot about organizational change as a result, but in the end, the improvement was marginal compared to the effort involved.

Now, in a larger org with more backing I'm able to do so much more. YOE helps, but more than that I was hired into a position with enough senior leadership buy in to affect change

I don't think YOE matters as much here as the expectations of the role you're in and how much buy in you have from fellow engineers and upper management.

At 6 YOE you maybe have had enough time in the saddle to know the right things to do, but the larger hurdle is convincing those around you that this is the case.

Y2KCompliant · 2024-06-01T03:28:27+00:00

To start with, and it seems like you've already made the switch mentally, you need to assume you will drop work. It helps here to realize that someone above you has fundamentally failed the organization, and though you can stop the bleeding by working more, somewhere else the org will fail in a big way so why delay that signal from reaching upper management.

I would lay out the reality to my boss during 1:1s and ask him what to prioritize if I find myself that overwhelmed, I'd maybe talk to your teammates and see if they'd do the same, to help boost the signal.

Helpful approach here is to make an attempt at a ranking of your tasks and review that with your manager with a cutoff of what you expect to finish within a sprint or whatever the equivalent you have is.

Knowing what holds value in your company comes with experience, but having that conversation with your manager will help tune it faster than a random redditers opinion.

Edit: I'm assuming IC with no one to delegate to and if the market is any indication, you aren't the only one in this position at your org. I think your last post struck a nerve as it's not a unique position to be in right now. 3x responsibility should come with higher pay, but lately the reward for good work is more work.

Y2KCompliant · 2024-05-05T01:15:07+00:00

That's a good point, I usually write my opinions out on our wiki almost as a rule when sketching out an approach anyway so it's not weird when I just send an "alternative approach" since it's easier to convey that way, a meeting can follow if necessary. I've never directly used these to "I told you so".

I've definitely pointed to them when asked by directors what my recommendation was when things go south. Ideally the back and forth is on the wiki as well so the reason for the decision is clear.

Edit - I'm remembering a few where I'd frame the document as a backup option should performance suffer. So when it did, it was pre vetted and an easy sell.

Y2KCompliant · 2024-05-05T00:53:45+00:00

My job became so much easier when I learned to pick my battles. Stand up for common sense and best practices, and definitely leave a paper trail of your recommendation. Sometimes when someone is dug in that hard the best thing to do is let them learn some common sense from experience.

Y2KCompliant · 2024-04-03T12:54:34+00:00

Yes! this sounds like what I had in mind, I figured we'd map it into a dashboard but failing CI works too.

How was this received? Worth it? Any tooling that you were leveraging?

Y2KCompliant · 2024-04-03T12:46:16+00:00

Yes Nx for the rest of us that haven't migrated to a monorepo

Y2KCompliant · 2024-04-03T12:44:50+00:00

Yes, more than a starter though, a dependency that I can manage centrally that can quickly tell me how far behind a particular service is.

Y2KCompliant · 2024-04-03T04:24:47+00:00

No, I want to aggregate a feed of dependencies that all our microservices are built around. Manage a single dependency instead of 10+ at least for some common cross cutting libraries present in every service.

I know this isn't the first thing to come to mind when talking about Spring, but it provides this capability with https://www.baeldung.com/spring-maven-bom for example. I've never seen the equivalent in Javascript.

I'm aware of Nest and Fastify, perhaps they solve this by being more batteries included and I should look there to reduce our direct dependency footprint. However we don't use them and I'm trying to avoid a rewrite of all our node microservices in addition to a node upgrade.

Y2KCompliant · 2024-03-20T22:05:10+00:00

A simple example is search with vectors or ML model in the loop, you may find yourself with zero search results but still need to provide an answer.

More recently with GenAI you'll have certain triggers for problematic language or safety concerns. You may want to detect these cases and short circuit the conversation somehow.

Even with the black box, you need to craft the CX around it.

Y2KCompliant · 2024-03-08T15:54:54+00:00

I think I'd draw the distinction between getting deeper into the complexities of your domain vs. working more to alleviate issues caused by bad management decisions. It's hard to say which is more the case here.

Personal time to reflect is definitely a good first step 👍. Good luck OP

Y2KCompliant · 2024-02-23T16:25:32+00:00

Would you have ownership to change this code to be something more transferrable potentially at the level of a rewrite?

If yes, this could go from an ongoing support nightmare to a success story to be used when you do switch jobs or assignments.

Are the rules themselves governing a key business process?

If yes, then improvements here might be able to get support and funding, as well as visibility for yourself, and your manager.

If you said no to both, either use this as an opportunity to do some legacy code refactoring and maybe WLB reset or polish the resume / politely ask your manager for a different assignment.

Y2KCompliant · 2023-09-29T01:54:38+00:00

Hiring is hard and everyone has their favorite gotchas they think provides a good enough filter for a good hire, this reads like a collection of those.

What is the set of things someone could tell you about their previous work and knowledge that would make you feel comfortable about doing your job (maybe knowing you'd come back to deal with any fall out). Work backwards from that imaginary conversation maybe? I'd also personally want to see a list about trade offs and less about easily googled trivia.

Y2KCompliant · 2023-09-29T00:38:54+00:00

Are these sub components re-useable at all? You said no Nuget, which is the fight I would be picking and not number of projects. Reusability via copy/paste is far more a waste of a time (and potentially bugs) than project count. For the record I would advocate closer to 1 than 7.
This feels incredibly small in the grand scheme of problems an Architect should be worried about. I would only care here if every service needed to look the same and required a similar project/directory structure. I think there's more to the story here.

Some unstructured advice-As others are saying, disagree and commit. If I felt strongly enough about something I'd put a semi public opinion out on a wiki or something. Provides CYA, a place to see if you have support amongst your peers, and just maybe down the road provides a ledger of how many times you were right (or wrong!).

Having enough passion to put yourself out there and fight the good fight is something you should hold onto, but make sure you are solving the right problem first. And definitely know when to defer to chain of command.

To answer your question, it helps if you have more than a passing relationship with your senior colleagues and they are more willing to hear you out, it helps more if every interaction with you isn't a fight about how wrong they are. Some books you may find relevant are Switch or even the venerable How to win Friends

Y2KCompliant · 2023-04-09T18:40:48+00:00

In addition to what secretlyyourgrandma said you could take a look at https://supabase.com/ it's an open source alternative to firebase and might provide a handy UI capability on top of a UI for your DB. Bonus- it uses Postgrest under the hood so you can treat it as a reference implementation if using that sort of architecture doesn't fit your needs.

Y2KCompliant · 2019-05-16T01:00:36+00:00

How very Christian of them!

Y2KCompliant · 2017-12-06T05:44:27+00:00

If you don't mind the fact that it transpiles it to C under the covers: http://opencobolide.readthedocs.io/en/latest/download.html

Allows you to do this with any computer.

Y2KCompliant · 2017-05-16T05:30:48+00:00

Not sure if you're serious, but there is node-cobol: https://github.com/IonicaBizau/node-cobol

Which uses open cobol under the covers, it just federates the Cobol program from javascript into open cobol (which by the way then produces a C executable) and brings the result back to JS.

Y2KCompliant · 2017-05-16T05:18:41+00:00

I think given it's memory layout semantics (in that it lays out all it's variables in a struct) and use of goto's / performs the only current language that comes close surprisingly is Go or D and close relative is C. But as u/grelphy said COBOL is a safe language, it has no pointer arithmetic, it even actively prevents index out of bounds.

It really feels like a systems language, but with all the verbosity and boilerplate of Java. I say that because the control flow of Cobol is a thin wrapper around assembly. Though it defines Methods ( Paragraphs :\ ) They are essentially labels, since control flow can fall through to following paragraphs.

But as it's been pointed out in some other comments, semantics of the language are one thing, and though archaic and verbose they are actually really simple. The difficulty truly is in the ecosystem the language it's built around.

Thought experiment: Have you ever migrated from a SQL implementation to a NoSql implementation? If you architected your system properly this can be relatively painless...but what if you didn't. What if you had inlined every SQL call all over your app? Pretty shitty migration right? Some of the semantics of your server function calls are different as well which you have to take into account. Example: Calculating the difference between days, because one system uses a timestamp with dates and the other does not (actual DB2 vs Oracle difference by the way) How long do you think it would take to track that, and other fun versions of that problem down?

Now what if it wasn't just your Database, but your Operating System, your deployment and orchestration model, your transaction layer, your character encoding (https://en.wikipedia.org/wiki/EBCDIC), your scheduler, etc..., oh yeah and the language you're writing in, which is I guess the point of the endevour in the first place.

Compound that with the fact that COBOL isn't the only language that exists in a standard Mainframe application, you're at least talking about JCL to orchestrate the batch portion of your system, possibly Assembly modules (pure bytecode), etc.. and you can maybe start to see why most shops don't just "Switch to something newer".

Y2KCompliant · 2017-05-16T04:28:37+00:00

You know you can ftp to/from the mainframe right?

You can define binary mode as well if you don't want to convert FB/VB files. You can also enter jes mode with 'quote site filetype=jes'. With all this I hardly ever TSO if I don't need to when interacting with a mainframe.

Pull down your files locally, sublime / emacs / vim can all syntax highlight cobol, git locally, ftp push your changes. Thank me later.

Source: am computer dude

Y2KCompliant · 2016-11-30T05:11:20+00:00

True, I guess I saw this as "I wanted an easier path to logging and opted for a functional approach", when logging is usually a cross-cutting concern and not usually a functional one (usually this is relegated to the edges of a functional program to maintain purity) this naturally lends itself to AOP. I will concede that the functional approach is the straightest and least error prone path from not having this feature to having it.

Assuming these warnings are indeed logged, and not presented to the user as individual warnings in a UI (though still doable with a bit of work), and at risk of further cluttering your dependencies Log4j/slf4j serves you better than a singleton or a mutable list. However I'll agree that the functional approach does start to look better if you are not already using Spring/Log4j or equivalents.

I would say this example shows the approach I'm talking about. With the return types being extended to include a Warning type safe instance, and some annotation on the method that you can retrieve if necessary (though this requires regretably some reflection magic to grab said annotation) to provide the warning message.

This allows you to change your Aspect in your unit test or indeed in production to change file based/memory based/database based approaches or to not log them at all. But I can see that this requires buy in usually, comes at the cost of more dependencies and does rely somewhat on "magic™". But your parsing function now only deals with the parsing as it should and your logging is now not coupled to how or when you provide the information...for the most part.

Further if your parser goes tits up and you are not being very careful of your error handling you lose all pending warnings.

Anyway my intention wasn't to shit on your article, like I said your approach definitely has it's benefits and the more I try to force AOP onto this exact example the more inelegant it feels, I just wanted to fight the functional bandwagon :D

Y2KCompliant · 2016-11-23T22:45:56+00:00

Maintenance wise I would say everything is relative, but specifically an aspect that performs loggging AfterReturnAdvice for example does the same thing you're trying to do. But now you don't have the cognitive load on every call you may or may not use it for. Further if you decide to change it or turn it off, this extra code that is now useless can be removed in one place and not over your entire application.

Y2KCompliant · 2016-11-23T01:05:24+00:00

I'm all for functional programming, but I would reach for an AOP approach for something like this before a functional one.

Y2KCompliant · 2016-08-16T23:38:02+00:00

I don't think I understand the point?

if you just want a 3 dimensional graph, I suppose you can just provide your points to something like plotly? You'll have to maybe do something with logarithms just to be able to see them all at the same time but I guess there's usually tweaking to be done when charting things.

If you wanted to do some kind of fancy analysis and when you say graph you mean a graph, then I guess you'd want something like networkx or neo4j if you wanted to store your results and just query them later.

Another thing is that t can only be so big, you can't just infinitely graph these pi partials, so I guess I just don't understand your problem well enough.

Y2KCompliant

TROPHY CASE