711 karma · joined July 9, 2012
Stack of papers, flight of stairs, layers of onions, circle of life, etc. they all just harken back to what it actually is without having to define it directly.
Hilariously, this results in stuff like Copilot getting released to great big legal problems. Only then does the C suite actually notice the project and get upset that it is a legal nightmare for them.
I think the real secret to winning in big tech is that your job is just to keep your head down and keep the money rolling in without causing headaches for higher ups. Increase sales, make customers happy enough to keep paying, maybe release a cool product. But more importantly, don’t cause a major outage, burn the PR team, or get caught up in a legal kerfuffle.
https://en.wikipedia.org/wiki/2020_congressional_insider_tra...
The documentation is a little unfocused, but the pitch is good. If we assume the pitch is the primary purpose, simplifying the user experience should be the top priority. There’s a bunch of tools that have tried to solve the “throw file at Mom” problem, but I haven’t seen one work without putting my files in someone else’s server.
I’m not sure how you differentiate this from Plex, WD myCloud, OneDrive, or Google Drive. That’s an important factor considering how easier some are and how powerful others are.
You built a desktop UI in the browser to share files? That’s a bit much for anyone to take a serious look at. It’s the same problem as documentation and this post: needs more focus.
If you’re enjoying making it, and it does useful things for you, have fun! But I don’t see it getting much feedback or traction due mostly to lack of focus, but solving some of the technical limitations would make it much more broadly applicable and would help as well.
Powerful type systems and compilers that catch your mistakes before you can run anything is the best kind of testing. It’s fully automated and will inform you about most things early on. Practically, this kills dynamic languages for projects expected to become larger than proof of concept (pydantic, typescript, etc. mitigate, but must be in and enforced from the start).
After that manual testing is the most important. Specifically because it can be done by hand with isolated inputs and outputs. This won’t catch the refactoring breaking something disparate, but will ensure you can reproduce production issues with the code locally where you can expect it.
After that, integration tests are the most important. Give the whole component/system an input, and verify the output. This should be as fast as possible but should mock as little as possible. This should be able to be done from a local machine with a debugger running and still be fast. If an integration test takes half an hour, it’s never going to get run except on a Thursday at 6pm when you’re trying to get out a change before the Sprint review. Then it will fail and make life hell, because running it is so slow that running with a debugger is going to be hell.
After that, logging is the most important form of testing. Every input or start of a workflow should get an ID that follows it through the system with logging to watch it go. Any problem identified should include that Id so that you can grab logs from all the disparate systems. Specifically, that ID should be attached to the inputs or each component so you can replay it in a controlled environment later.
Then you finally get to unit tests, because once your software works as expected, they let you lock down the implementation and ensure that any changes will get flagged by the tests. If you lock down the unit tests before the software works, then you wind up having to go back and redo the unit tests for every issue found, as the implementation wasn’t correct so the unit tests can’t test it. This is the big lie of unit testing. They don’t prove correctness, they prove implementation details.
After that you want to get to end-to-end that workflow the whole user experience with a product or system. But if you don’t get there, that’s really okay.
Most problems are caught by the compiler, manual tests, and integration tests during development. Any problems that do come up can be identified quickly and repaired by the highly inspectable infrastructure that provides you IDs to dig out logs for any input, and while you’re fixing the issue, your unit tests will let you know when the implementation has changed in a way that requires more thought (though the compiler probably did first and the unit test complaints are just noise).
Programming languages are all the same, so learn 3 or 4 new ones and discover that you can probably write in any language for an interview (then do some in relatively unfamiliar languages for kicks and giggles to practice).
Tech is all the same. Take data in, poop data out. That’s the whole job. The formats and protocols change, but once you starting thinking about your stacks as data-in, data-out, they all start looking the same.
Make video games or hardware drivers from scratch, those are the hardest things to make. Video games from complexity overload, and hardware drivers from interface complexity.
In the scrum world, prioritizing a feature story over a debt story should require a strong reason with significant debate. Don’t let them live longer than a couple of sprints.
We call things BIOS and Boot-loader and Operating System by virtue of history, not necessity. It could even be confusing to a newcomer looking into development closer to the hardware and being told that all these programs are fundamentally different, instead of just being instructions and data getting shoved through a bunch of tubes in the processor and PCB.
I feel like the service is leaving a bunch of easy work on the table that would let people have a local development process that mirrors the remote development reality.
Rust just needs to sit down and make a good API for the whole set of string-ish types they have.
That's not true at all. It's just a different query language to yours and a different methodology to utilizing it. All the big BI and SIEM tools have post-processing capabilities able to do statistics at the Excel level, typically by creating new columns in the dataset. PowerBI has an excel-like function system for calculated columns. Tableau has a cross between Basic and Excel functions for calculated columns. Splunk and ELK are the standouts for letting you directly modify columns in their query languages, but the same sort of functions exist. In all of these tools, you can extend the query language as well through a plugin system, so for situations where you need a full programming language, there is an escape hatch (though a hard one to use).
> further processing in Excel. This is the part I want to compete with.
If you want to compete with Excel, you're going to have to get on its level. Specifically, the JavaScript must go. The reason big companies use Excel is because they have a couple of people at the company in the reporting jobs that can handle some programming, but most of the data entry and management has to be done by people who wouldn't know where to begin if you sat them down in a programming environment (IT gets called when people accidentally end up in the visual basic environment in Excel).
The majority of users do not want to live in a programming environment, so by having that be the primary interface, you're cutting the already small potential user base by another order of magnitude with the JavaScript environment. The advantage you get for an Excel-like query language is familiarity to the potential user base, less threatening environment, and additional control over the interface with the user (programming languages are generally poor interfaces, and JavaScript is no exception).
If this was very performant compared to Excel, then that would be a use case that could get you a niche while trying to build out the scale and interoperability required for successful BI tools.
The hardware integrators have a 90% chance of being from the world of industrial systems where closed networks and point to point runs means they get to pretend security isn’t their problem. They apply the same principles to their hardware installs.
AT&T wants to be able to administrate and manage their new hardware without keeping 1000 hardware integrators on payroll, so they have their contractors’ contractors develop a manual that can be used by AT&T Network Services, but this is out of the initial CAPEX quota, so it’s done on the cheap and no one does any real work. They just grab all the default passwords and architecture estimates from the integrators and put it into a set of hundred page books for different parts of the network.
The government, customers, and shareholders choose to not hold AT&T accountable for any failures in their network. They instead accept it as “the way things must be”, and AT&T is happy to buy into that story and do the exact same thing on every capital project and maintenance.
This is how you get telcos failing at security every time for decades. Their incentives as a customer-facing company running the worlds largest infrastructure projects encourage them to farm out all the infrastructure work to several layers deep of contractors with no real responsibility enforced by anyone.
Perhaps the big kerfuffle was overblown, or perhaps it instead slowed down the plans that companies had (since it was now a provable PR nightmare post-kerfuffle). We don’t have enough data to decide that. We do know that companies are currently allowed to act in anti-consumer fashion.
After data gathering, it’s no longer garbage in and garbage out. You’ll note the questions assumed a randomness to the results, captured the worst case scenario, and minimized it to something I can live with.
You can do this with everything. That’s the beauty of rational thinking. It’s less about knowing the absolute correct solution and more about being conscious of the process of decision, rather than letting intuitive cues be the only deciding factors.