HN Simulatornew | past | comments | lists | submit | thunderbong's commentslogin

text-to-speech

I went through the whole thread and I totally agree with you. Regardless of anything else, unless there are proper processes in place, blaming an individual becomes just theater. The overall goal for any system failure should be to improve the process, unless the failure was intentional or due to negligence.

Great fun!

You should add the 80 character limit on the title as well!


Great suggestion – added!



Thank you for your comment. I've heard the parent argument earlier as well. I wasn't aware of these points.


PgMulva


Thank you for that comment. I had initially skipped that section and went back and watched it after reading this.


I just did the same. It was a good ad :)


IMHO, that also should be addressed from the legal perspective very strongly. But forcing Safari for every Apple owner is certainly not the solution.


That's ridiculous. You can't solve a monoculture with the legal system. The only solution is forced diversity, and to that end, I congratulate Apple for being the last guardian of the web as a truly open platform.

(I still remember when communities like Hacker News were screaming and howling at Apple for daring to rid the web of Adobe Flash, a corporate-owned proprietary monoculture cluster-f**k of security vulnerabilities. The virtue of Apple's influence on the web is painfully obvious in hindsight.)


> You can't solve a monoculture with the legal system.

You absolutely can, and we absolutely have. You believe this because anti-trust action was derided as anti-growth in the latter quarter of the 20th century, by people who knew exactly what they were doing (see also: banking deregulation).

It's one of the major reasons we're stuck with such horrendous corporate and individual wealth inequality today.

Google should never have been allowed to buy DoubleClick, ship a browser, or ship general-purpose client operating systems.


Okay fair, you can avoid a monoculture with the legal system. Bit late for that now, unfortunately.


It wasn't really any better when Apple killed things off. For years afterwards I was running into devices that had embedded Java applets for configuration over the Web that no longer worked. Sometimes I'd run into an academic's personal web page that had examples that used Flash or Java and no longer ran for the same reason. There was a lot of useful legacy code that got broken overnight when Apple led and others followed in killing off these kinds of plugins.

For all the claims about security problems - and there were many and the complaints were valid - people seem a bit too willing to overlook the much greater attack surface of modern browsers that still incorporate similar flexibility and functionality but through other protocols and native Web standards now instead. For better or worse today's "evergreen" browsers roll out new functionality more quickly than before but their most important innovation was introducing frequent automatic security updates to a general non-technical audience at a time when that certainly wasn't the default for most desktop software. Take a look at how many significant security issues get fixed in any of the major browser on each update cycle and you can see that even today this is still far from a solved problem.


Yes, you can. See the landmark United States vs Microsoft 2001 antitrust case.


I'm not sure that's a great example. Even though Microsoft lost, it had no real consequences - the company was not forced to split, MSIE remained a core component of Windows, and Netscape was still forced out of the market because they couldn't compete with free MSIE. By 2003 or so, MSIE was up to ~95% of the market.


Allowing Google to use their control of the web to kill the most effective method of blocking ads is the solution?

No.

People need to stop using Chrome and Chromium based browsers and use browsers based on implementations of the web standards that are out of Google's control.

Firefox on Android supports the full version of uBlock Origin.

Chrome on Android doesn't support it.


>IMHO, that also should be addressed from the legal perspective very strongly

Then do that FIRST (or at the same time). Don't give us, yet AGAIN, the tired bs song and dance about how you'll make things worse first and then totally someday address the other part properly, and oops what a surprise that turns out to be too hard nevermind.

>But forcing Safari for every Apple owner is certainly not the solution.

Objectively it is a solution though. Because it's been done, and it's been more effective than nothing, while meanwhile nothing has happened from a legal or political angles. If a better solution can be done down the road great, but a hack dealing with a problem non-optimally can absolutely be better then just having the problem completely unaddressed. And count me skeptical that any government is going to have the will or capability to actually address what a lot of us already hate about not just the Chrome monopoly but that entire approach (I don't in fact want my web browser to be a full lowest common denominator operating system with low level hardware access thanks). I dislike much of what Apple does now but I'm glad their selfish interests have happened not to align that way either. Until monopoly lock-in gets better addressed, one of the main ways to push back is via another monopoly lock-in that has different incentives.


Over the years, I've seen many comments dismissing Excel. But as many people who've worked in enterprises know, Excel is a godsend for manipulating reams of data for non-programmers who can think analytically. Of course, complex formulae and extensive VBA functions become a tech debt over time. But implemented properly, it provides a solution which doesn't require huge management approvals and increases productivity.

I'm sure that these new features will find a lot of use amongst many people. And seeing these Excel innovations is heartening.


Even as a programmer I find Excel pretty useful for anything involving numbers. The fact that everything is reactive allows for very fast iteration when testing stuff.

I wouldn't necessarily want to maintain a really complicated spreadsheet but I stop using spreadsheets once it gets anywhere near "complicated". It's still valuable for what I use for.


I work at an airline where Claude is replacing data analysis tools like excel, data visualization tools like power bi, all that's left is dynatrace because it does it all automatically like Claude does. Many bespoke data processing or data analysis tools for non programmers are being replaced by Claude suscriptions, like excel, power bi, spss, tableau, those are the most used I think. No Python data analysis nor big data tools like pandas, numpy, apache superset are being replaced though


I would argue using Claude in replacing a spreadsheet is potentially more of a tech debt than the spreadsheet itself. Now if you would use Claude to build a point application that performs the same standard analysis it might be better, but only marginally so.


...an with Claude/LLMs you still cant be sure if there is some where a hallucinated mixup in some numbers, yielding wrong results:

If I select whatever datarange in Excel, I know I can rely on the numerical output.

Though, Claude became much better with this


Their only complaint with Claude has been hallucinations when using it for things like remembering business rules, but that's an easy fix since it has no Access to them and the company is large enough to be different from other companies which causes the hallucinations


I love Claude and use it for many things, including analyzing and manipulating Excel files. But I’m not convinced that replacing spreadsheets with Claude is the right approach.

Over the years, we’ve seen many platforms promise to replace spreadsheets for a particular use case or industry. Businesses adopt them and push users away from Excel, but in many cases, those same users eventually find their way back to Excel to do the exact same work.

My concern is that we may end up creating another dual-system maintenance problem, where some people use AI and others continue using Excel for the same business process. Over time, the two versions inevitably diverge, potentially creating more problems than they solve.

Excel is much stickier than most people realize. I think the more interesting opportunity is figuring out how AI and Excel can work together, rather than trying to replace one with the other.


The other aspects is the new generation doesn't understand it. During interviews in marketing but also for a medical field expert, I often ask "make a small budget so you'll see how your bonus will work", and even the PhD, which is the top academic level, couldn't use a basic formula. How do they deal with data during a PhD? "In Prism", she said.

Same for marketing students and, although it's a lower academic level, they still need Excel for prospect lists.


Recent grads at all levels always suffer from this problem. The issue is they’ve not needed to use it with enough frequency in their academic lives to build the knowledge or muscle memory. Things have improved a lot in past 10 years or so, but it’s even true with many Finance and Accounting grads (that’s who I hire). Many of them just have never seen real world business data and working with it so different than the contrived information they had seen in coursework. That said give them $15 to spend on Udemy. Then, give them a few assignments, with real world business data. And most people pick it up pretty quickly.


A PhD is not for teaching about specific software tools, and hopefully even less so about legacy software from the 80's.

If you want people to be able to use Excel or service a mechanical typewriter, you need to spend extra effort to teach them.


I'm one of those. Excel's ease of use isn't relevant if you already know how to use Python / Jupyter / DuckDB / whatever.

The mental model of describing a series of reproducible transformations on normalized tables is more intuitive to me.

Excel lets you do too many things. As a result, I mostly see spreadsheets that aren't much more machine-parsanle than a word document.

We had to write a score-table at a party lately, and a while ago, and I managed to get it working with DataSpell faster, than it took us to figure out how Google Sheets stupid date-parsing works.


Sounds like a fun party.


So, Excel is just the poor man's shadow IT? I like that picture.


By the time it takes to make a custom filtered table non extensible UI for an api, the excel guy is finished three times over


I can’t count the number of demos I’ve seen that were “small team, multiple sprints” to produce something that could have been done in a lazy afternoon in excel by a single person.


It’s a common pattern in enterprise IT to take a useful spreadsheet and turn it into an application. Without fail, they turn into a forever chase of excel features re-implemented (and poorly) on some front end. Entire teams dedicated to features that would be two clicks away in excel ootb.


Yes, I have already three such projects on my CV, failed attempts to replace Excel.

The root cause for failure is always the same, not understanding all use cases for 100% of the department users instead of only the representative group present during UI/UX sessions, coupled with the human natural resistance to change.


Indeed. Sometimes it's hard not to think about gaslighting in this field.


I mean spreadsheets are amazing, but excel is still a shitty piece of software (in my books)


I recall excel being decent once upon a time, back in the early 2000's, before the ribbon interface was added.


The introduction of the Office ribbon was one of the biggest improvements in software that I have ever experienced.


Every time fossil comes up, I hear this same issue - "why is there no rebase?"

And honestly, I've never been able to get this argument. It's a version management system! It's supposed to maintain the history of what's been done, both good and bad. In fact, that's the whole point of a VCS, isn't it?

IMHO, if we want to show a different path than what's been actually taken for the codebase to reach where it is now, we might as well use a network drive to store the different versions. Why bother with a VCS then?


How about temporary commits locally, that then get squashed to ensure each build cleanly? Or secrets that shouldn’t have been committed?

Maybe it what an ironical question ^^


I use both, and I prefer fossil. But my coworkers hate fossil because they can't fake their commits to make them look good. This is something I actually like about fossil: git has tools just to make things look pretty even if they can cause serious headaches (rebase), so users are skewed towards good looking timelines made with dirty commits then rearranged and squashed. OTOH fossil forces you to do your best but accept that sometimes you botch it, and have to mark a commit as "does not build".

And I don't know why (forces you to review and cofirm?), but I had never commited unwanted stuff with fossil. But I had with git, probably by using the -am flag without realising a whole new dir is now in the scope.


This prioritises accuracy/history of what happened, but this has significant disadvantages and practically no advantages (other than "accuracy of what happened".

There are cases where you really do want an append-only leger, where tampering with history is malicious. -- But, generally, it's preferable to be presented with something tidy.

From some other comment in this thread, I get the impression it's possible to re-present a set of changes in a clean/tidy way? That seems a better way of putting it. "You can still have a clean view into a set of changes while preserving an accurate history of what changed".

What's hard to understand is why you'd be against the idea of tidy communication/presentation of changes in the first place.


> but this has significant disadvantages and practically no advantages (other than "accuracy of what happened".

...which is a very big advantage, big enough that it outweighs the disadvantages in my opinion.


Can you help provide examples from your development experience where "knowing the accurate history of what happened" was a very big advantage, to the extent where not having this knowledge would have made things very difficult?


Here a developer thought that redis would be a good add to the stack, so we decided he should try. It turned out that it didn't fit, mainly because it needed to touch code in more places than anticipated. We went back to starting point, but the project now carries a "no more redis/cache attempts before reading this one, please" fossil. New attempts can't say "oh, I didn't know this was attempted before".

With git, this kind of experiment would be hidden with a "reset hard", and probably will happen again when people forgets, someone says "didn't we try that a year ago?" but we have no records.

This is very helpful in small private teams, not so much in biggest teams (kernel), pass-by PR environments (github), or public CV-oriented repos (no mistakes allowed there, only pretty linear timelines).


This sounds more like some elitism. Who cares how your coworkers got there, the point is to have good history at the origin. People don't need to see your dirty laundy, there is nothing interesting about it.


Agreed.

In teams, only the history of what is committed to shared repo is important.


> People don't need to see your dirty laundy, there is nothing interesting about it.

We disagree here, thus we prefer different tools. Nothing elitist here.

I have seen git people throwing away repos and start again just to hide mistakes/pivoting and look "pro" and "right from the start". Or worse, I have seen people botching repos to others rewritting history just to make them look clean. I embrace mistakes, and sometimes they become useful later to replay train of thoughs.


There is something wrong with this explanation.

In the most common git setups, you never force-push to master - so a coworker can't rewrite history of master branch. Forges have protection rules, but even if your hosting does not, then the "git pull" will throw a ton of errors after history rewrites. So both fossil and git are similar in that regards.

On the other hand, unpushed branches can be rewritten any time in git.. but this applies to fossil as well. If you have not pushed your fossil changes, it's just a file on disk - you can delete it without pushing and no one will ever know you had intermediate version. Or work in "git" and only export to fossil (or svn or cvs or whatever) once things work.


Secrets that is committed anyway has to be assumed as compromised. So those secrets must be immediately changed. Removing it from history would help a bit, but is not a reliable mitigation.



Your definition of version control isn’t the same as mine, probably. Why even ask this? People have preferences and different beliefs.


History is immutable ONCE it’s merged. Prior to that, it’s malleable. We rewrite our branch history fairly often. I’ll take a big PR that’s ready, and rewrite the history in a way that tells clear story. This lets me stack PRs so it’s easier for coworkers to digest the work. It hides the messy reality of how it was constructed. It lets the development process follow evolutionary design, without review being miserable at the end of the day. This also makes git-blame 6 months later way more useful, as the commits end up much tidier with better messages and clearer story being told.


This was CVS/SVN approach, and that's the reason git won so quickly (no, it was not github like some people claimed, I've seen git become popular in my circle before github was a thing)

I am not sure if you used CSV/SVN before - I did. It maintained the history of what was done in a very immutable way. The branches were heavy-weight and were only used for Serious Business, we generally had a person responsible for branching/merging. You only committed stuff which was in great shape and passed all the tests, just like Fossil wants you now.

And there were manual source code copying, so much copying.

- You are writing a feature and got interrupted mid-work to work on something else - copy/tar those files and restore from svn (you could also do a second checkout, but that destroys your cache).

- Want to send incomplete changes to friend? run "diff" and send them the patch by email, or place that patch file on shared disk.

- Your check-in failed, you need to merge in in latest changes from master? better tar up your work in case you break stuff.

- Are you doing new feature and want to see if refactor will improve it? don't forget to make a copy of changed files in case it does not.

None of this is worth committing on master. Who would want to share an incomplete feature which does not build / does not pass unit tests? Or an pre-refactor version of code which does not work?

Turns out using "git" covers all those usecases, and that's why it's the greatest thing. Fun fact: we've started using git in our team using git-svn, without central git server - we had mutable and shareable commits until the last moment, when we pushed it to central svn server.

IMHO, if you only want to record the final path code takes, and you plan to use "cp", "tar" and "patch" for throw-away work, then you might as well use a "releases" directory on FTP with timestamped archives. Why bother with VCS then?


Can none of this be addressed using "probate branches"?

https://fossil-scm.org/home/doc/trunk/www/private.wiki


And this highlights my frustration. I don’t want to have this debate. The tool should allow its operator to set whatever level of strictness or purity they want for their project. Fossil already offers a million settings. Add another and make me turn on “dangerously-unsafe-rebase” to get the feature if need be.


What you're wanting is against their philosophy. However, there is removal via shunning. There's also the query langauge to control the view. So, there's everything you need to do what you want.

Obviously that's going to take some figuring out for queries and aliases. But it seems doable to me.

Awkward, yes, but doable. AFAICT, they've provided a way to do things that go against their philosophy should anyone be inclined.


Suppose a secret like some personally identifying information was recently leaked into the main branch. You are legally required to scrub it. How do you fix it?

Ideally a repo needs to reflect the state of every event that happened. Practically there are edge cases when it's just best to rewrite history.


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: