What is Reddit's opinion of
Lobsters?
From 3.5 billion Reddit comments
➔ Lobsters website
By popularity on Reddit, this Service is:
100 reviews of this app found across Reddit:
The discussion over at lobste.rs had someone actually pull the indictment and it seems that he has connections to criminal conspiracy with someone who wrote a keylogger. So the daily beast is misrepresenting the story at least a little bit.
Link to discussion: https://lobste.rs/s/ncnsli/fbi_arrests_hacker_who_hacked_no_one
Programming is in a pre-literate state. Even the smartest programmers among us are equivalent to scribes in Ancient Egypt. We can only easily read code we ourselves wrote. Recently. Everything else takes a lot of effort, tongue sticking out. We're light-years away from the modern state of reading comprehension: most people can't write novels, but they can read novels. And we learn in school how to almost effortlessly compare and contrast single paragraphs from very different books.
Backwards compatibility is the biggest roadblock to a literate society. Writing took several failed civilizations to erase dead ends. Hopefully we can manage the transition more gracefully.
Everyone interested in this topic may find the comments here by David Chisnall interesting. He was the chair of the J extension group but left due to how the foundation operates.
Don't forget there's also https://lobste.rs
edit: given a few invites, happy to continue if you PM with your email & a working implementation of fizzbuzz, and promise to never bring up 'gender in computing' topics there. Please don't ruin it.
edit squared: I was joking about the fizzbuzz but you're all very thoughtful in actually submitting :) Don't forget to PM me your email!
edit cubed: I'm anonymously collecting your code into a pastebin so we can all see and compare - http://pastebin.com/pirgyFcG
Si les résultats sont secrets, pourquoi est-ce que je m'emmerderais à faire plus que le minimum? Le résultat de la transparence dans d'autres pays a été une amélioration des résultats des inspections. Par exemple.
Il y a même des extensions qui affichent ton score sur les sites web de livraison de bouffe.
Why I no longer contribute to Racket
> In January 2020, I told two members of Racket’s core team that I would no longer be contributing to Racket or participating in the Racket community. Why? Because of a history of intentional, personalized abuse and bullying directed at me by another member of the Racket core team: Matthias Felleisen.
(Racket is an open source programming language, maintained in academia)
Discussion: Lobste.rs, Hacker News
Resources linked by /u/AnthonyJBentley will be hard to beat but here's my 2 cents for whatever it's worth.
It boils down to sane defaults. I'm pretty sure you can secure a Linux box as well as any BSD the question is what you will get by default?
OpenBSD by default:
- disables ssh root logins
- partitions the hard drive into multiple mount points
- has Xorg (xenocara) running NOT as root (before Linux got there)
- uses privsep, heck ping has privsep on OpenBSD
- practically no services run as root by default
- has better documentation (which leads to less mistakes in using software)
- has sane defaults (disabling old protocols in httpd(8), old password schemes etc)
- exploit mitigation techniques are on by default (ASLR, W^X etc.)
- you now have pledge which is like the security frameworks in Linux but software is actually using it :)
- many more..
Do defaults really matter? Well there was this nice blog post from the author of redis discussing their security policy. Essentially stating that each publicly facing redis instance is a rooted box if the service runs as root. I commented then stating that 15.617 machines are already indexed by Shodan, a month later when someone publicly blogged about his box being owned I commented again after checking that we now see 16.344 more redis instances. Essentially the end result is 727 more instances vulnerable that can be instantly owned since the author published that blog post. That means there are ~~16.344~~ 16.367 (yeah, I just checked it grew again by 23 hosts) servers that can be instantly owned because the default configuration doesn't bind to localhost.
PS. they also pioneered SSH (yeah, the same you use on Linux)
I made this comment on Lobsters a few weeks ago about dynamic typing and speed of development:
> Your comment about fast startup time has put the image of the Ariel Atom in my mind. In BBC’s Top Gear, they test a car against a motor bike, and although at the ~~offset~~ outset the bike is faster, when the first curve comes, the car whizzes by and never looks back: its design allows it to stay more stable when you need to change directions. I may be looking to much into this, but I see an analogy to typing disciplines: a dynamically-typed language can help start off fast, but once the first big refactoring comes, the statically-typed language would have allowed for faster turn-around time.
I'm not totally sure why there's not more activity in the comments. There's some conversation over on lobste.rs https://lobste.rs/s/j1gmob/room_where_it_happens_how_rails_gets_made.
I appreciate that this is a difficult topic (I know, I wrote it!). If you're struggling for how to say something, I invite you to try out the NVC framework.
I wrote this hoping for some conversations. My twitter DMs are open too if you want to say something but don't want it to be public.
> Is there anyone here willing to refer me?
Sorry, but I got my invite privileges revoked for inviting anyone who asked. Some people like the "private club" setup a bit too much.
For those still wanting to join the circlejerk, if you can't use the freemason-inspired "ask one to become one" mechanism, you can ask for an invite in the chat: https://lobste.rs/chat
YAY! And they've been busy making three releases so far.
lobsters discussion:
https://lobste.rs/s/wcw6c7/youtube_dl_repository_restored_at_github
https://lobste.rs/s/icegvf/will_risc_v_revolutionize_computing#c_nbz4jj from David Chisnall, which was the chair of the RISC-V J extension working group.
> Note that Andrew’s dissertation is using integer-heavy, single-threaded, C code as the evaluation and even then, RISC-V does worse than Thumb-2 (see Figure 8 of the linked dissertation). Once you add atomics, higher-level languages, or vector instructions, you see a different story. For example, RISC-V made an early decision to make the offset of loads and stores scaled with the size of the memory value. Unfortunately, a lot of dynamic languages set one of the low bits to differentiate between a pointer and a boxed value. They then use a complex addressing mode to combine the subtraction of one with the addition of the field offset for field addressing. With RISC-V, this requires two instructions. You won’t see that pattern in pure C code anywhere but you’ll see it all over the place in dynamic language interpreters and JITs.
It was very much cherry-picked numbers.
And also, ARM64 is really a quite dense ISA in practice.
Nice talk! I just watched this and posted a summary on lobst.ers, copied here:
- Application: designing / synthesizing molecules from "molecular legos".
- It sounds like mostly do brute force search in the style of "superoptimization". That is, generate a bunch of candidates in a combinatorial fashion, and score them. So they need both interactive computing like Python, but also raw speed.
- Common Lisp fits the application domain of molecules because it's all trees and graphs
- They want to use GPUs to do this search, hence LLVM.
Back story:
- Crazy computational chemistry professor has been programming for 20 years. Claims he programs for 6-8 hours a day!
- Has problems with interfacing Python and C++ (I can relate), and stumbles into Common Lisp 5 years ago.
- Combines an existing Common Lisp implementation with LLVM. There is a complex bootstrapping process.
- Wraps the unstable LLVM C++ interface in Common Lisp, so you can do metaprogramming on C++ with Common Lisp!
- Generates his garbage collector! The garbage collector has to know about C++ types that are pointers.
- Wraps the ASTMatcher API to do source-level refactoring of C++ ?
I had a conversation recently that you might find interesting: https://lobste.rs/s/7vqmxt/announcing_rust_1_17_rust_programming#c_zkoumk
In particular:
> Every few years OpenBSD makes a change to ABI that results in old binaries not running. Everything must be recompiled. It’s fairly complex work just getting libc and a minimal C compiler over the bump, but the end result is a working system with a standard set of utilities like sed and awk and a C compiler and 9000 tar.gz source archives for everything in ports. Somebody types make and 3 days later there’s a pile of packages for all the stuff that can be bootstrapped from C and a pile of smoldering ash for the stuff that can’t. Some languages, those which can be bootstrapped from an older version built from C, survive. Others don’t.
...
> Rust does now work on openbsd (at least for amd64) but it involved a lot of heroics. Compiling some things on a linux system, copying to openbsd, running linux binaries under emulation on openbsd, compiling some more pieces, etc. I don’t think there’s any way somebody replicate without tremendous effort.
> The plan9 c bits of go are all included. Like luajit makes heavy use of dynasm which is itself written in lua, but luajit also includes a mini lua interpreter in the source to bootstrap. Same with ocaml. The main compiler is written in ocaml, but there’s enough of an interpreter written in C to compile itself.
What is really amazing is how easy people's opinion's are influenced with a "fake news" story. Read this forum for a bit more to the story:
https://lobste.rs/s/ncnsli/fbi_arrests_hacker_who_hacked_no_one
Pretty much everything you watch and read has been crafted to get you think a certain way. In the old days it was called propaganda.
congratulations, you unknowingly channelled lobste.rs:
> Lets put things in perspective. Given a mediocore team of devs, which would you rather have them use:
> * Java > * PHP
> because (sadly) this is pretty much the shortlist in many shops. Both might be poor choices, but at least Java keeps you from trying to add 1 and “2”, or accidentally introducing a typo’d var into your program
I’ve just launched the site and—what a coincidence—Reyk Flöter has started looking for a developer for a new project (in Zurich, non-remote). Please contact Reyk, if you’re available or can recommend a friend.
Thank you!
I don't think GamerGate drama is "usual" for FreeBSD. It's not a terribly dramatic group (side effect of being small and close-knit), and when I've seen drama, it's usually complaining about the GPL or some such. There is definitely a bunch of brigading going on in there, as this drama would never have shown up otherwise.
FWIW, if anyone wants to look at an actually coherent discussion of the code of conduct, lobste.rs has a good one. (Actually, this is true of pretty much any tech discussion on Reddit: if you want to read an actually reasonable discussion, find/post the story on lobste.rs.)
Hi there, what do you make of this critical article on Urbit (and discussed at lobste.rs)?
Urbit seems to have a bad rep in the tech community; so I'm curious how general users perceive it, as well as what its future holds.
Here’s a really hilarious begpost very very politely imploring one of the most upvoted users of the site to stop posting far right tech. I’m sure it will result in the extremely karmatic user stopping their behavior or else get kicked off the site.… and not, say, being granted moderator bits.
It’s amazing how effective being polite can be in my head.
>Less seriously, how can I release the library if I’m now quoted as a strong proponent of using simple Haskell? People will be confused.
Heh. But seriously: I wouldn't want the Haskell community to religiously codify these things, and instead focus on improving teaching materials. That's one thing I sorely needed as an established beginner looking to take it to the "next level" (intermediate).
I like this comment form lobste.rs to that effect: "I think any of these kinds of software development “manifesto” documents read like a crusade. I’m all for shipping boring simple Haskell code, but I agree a better approach would just be a bunch of “cookbook” style articles demonstrating building simple things with simple Haskell.". Something like typeclasses.com but open source, community maintained and widely available?
> conflating induction/coinduction/laziness is sloppy, and unfortunately a lot of our learning materials explicitly encourage this conflation.
Apparently some Haskellers like it that way
I feel that this is the right place to drop https://lobste.rs/about
Looks like it fixes the objectionable xxx-ban practices of HN (slowban, voteban, hellban, secret moderation). Now if I could find an invite...
What's more telling about the profession is that the status quo in cloud services that need to be configured is YAML. And often YAML generated with Go templates or worse.
People rightly complain about 70's text sludge: shell, make, awk, m4, etc.
But IMO 2020's text sludge is even worse: YAML (complete with whitespace pitfalls just like make), with embedded shell, on top of weak and ugly specified macro languages expressed in YAML, like Github actions.
example: https://lobste.rs/s/v4crap/crustaceans_2021_will_be_year_technology#c_t7tj0u
I can see why you would say that a configuration language shouldn't be so desired. But it IS because the status quo is so exciting in a bad way. A boring configuration language would be a very good thing, but we don't have one.
There was a ton of good criticism of this article over on lobste.rs. My summary of it is "literally everything contained in the article is wrong in one way or another".
I don't know of any good direct Reddit competitors (there was a time when I'd say https://voat.co, but not anymore unfortunately since Reddit cracked down on the less nice subreddits and they sought refuge in voat). I would however recommend adding hacker news and lobsters to your rotation of programming-related news.
He's talking about this: https://lobste.rs/s/rhz2eb/lets_encrypt_has_issued_988_certificates, https://lobste.rs/s/81rcoz/lets_encrypt_now_being_abused_by.
I don't think it's a bad thing... If I'm going to get phished, at least do it over https so that all the ISPs in-between don't find out and laugh at me.
I am all for focusing on benefits of safety instead of how safety is done. I am very uncomfortable with focusing on algebraic data type, pattern matching, etc., in that if that's what you want, OCaml is more mature.
I think lmm is echoing my sentiment on Lobsters thread, "is Rust better marketed OCaml (e.g. with C-like syntax)?" If it is, we could work on C-like syntax for OCaml and save lots and lots of efforts.
jcs was banned from HN and he started https://lobste.rs
https://jcs.org/notaweblog/2012/06/13/hellbanned_from_hacker_news/
On lobsters, they keep mod logs completely public. I love their transparency system: https://lobste.rs/moderations
Yes, politics will come to any sufficiently valuable cryptocurrency. Ethereum is unlikely to be an exception, so they (or whoever "owns" the source code) should pay attention to what's happening in Bitcoin land.
The most important lesson, IMO, is to be extremely careful with whom you place into a position of power. Demand honesty, transparency, and integrity from everyone, and be prepared to quickly show the door to anyone who can't live up to that, regardless of their technical prowess.
The subthread about the backends is what intrigued me most.
So it was possible to plug any backend into the crypto library, even one that actually includes snooping? How safe. Good thing it gets stripped.
The only one I currently use is lobsters (source code) technically it is a hacker news alternative but it feels a lot more like reddit to me, I like that it supports web mentions, tagging and has a overall clean look to it.
Its not that easy ... you may of course add RSS from various FreeBSD blogs but to be up-to-date with FreeBSD I follow:
- various accounts on Twitter
-- https://twitter.com/vermaden/following
various accounts on BSD.network
check FreeBSD related things on Hacker News
- check FreeBSD related things on Lobsters
-- https://lobste.rs/t/freebsd
- check FreeBSD related things on Reddit
-- r/BSD
-- r/FreeBSD
- check FreeBSD mailing lists
> The name "Lobste.rs" is a cute domain hack without any deeper meaning. It has nothing to do with self-help guru Jordan Peterson, whose fans started to call themselves "lobsters" about six years after we started.
I'd love this - I really like lobste.rs but I find that I don't meet the prerequisites in terms of coding knowledge much of the time! I see what you mean that sites like mathoverflow, while very interesting, just don't have the same kind of content - it'd be nice to have some lighter reading sometimes that's about interesting maths without having the aim of solving a particular problem!:)
Initially I think flairs were helpful because there were so few of them, so when you'd see flair like "rust", you could be reasonably sure that the person knew what they were talking about. As the community grows, there are so many flairs with no explanation for what the flair means, or why anyone should care about the flair, that it just blends in and doesn't mean anything. I think it'd be better to have something like the hats on lobste.rs where a user could choose to apply a flair to individual posts, like "Rust Community Team" when talking about community issues. Having flairs always displayed reminds me of email signatures that include tons of certifications, even if they aren't relevant to the discussion.
Yeah, I really don't know.
HN has its issues, but thinking about it I believe one reason I like it is that it's a fairly good one-stop-shop for generic tech news. I.e. right now there is some good discussion about all of the AWS announcements coming out of AWS re:Invent conference.
Reddit can sort of do that if I subscribe to the right subreddits, and if they don't degrade to image macro shitposting. But it takes a lot more management on my end to find, subscribe, maybe make multi-reddits (like the idea of this feature, but have ended up not using it for whatever reason), etc.
https://lobste.rs/ is pretty cool, as you get a generic front page, but you can dig into areas of interest through the tags. I would be very happy if that site took off. Or if HN stole that feature.
- I go for walks every lunch around campus trying to open doors that I have no business opening. I run after work three times a week. I also set my Apple Watch to remind me to stand every hour for a minute at least. I have a standing desk so I just set it to stand until I get tired and sit until my watch tells me to stand.
- I use the Kinesis Advantage Ergonomic keyboard and the Evoulent vertical mouse. I find my views are accurately reflected in this post. I used to have pretty bad pain in my hands when typing on my MacBook Pro.
- I don't slouch and it takes discipline. I pull my shoulders back and sit in my chair, adjusting properly. I push my monitors back and get more as I need. I also set my fonts to be larger than normal because I find that most text is too hard to read without making it bigger. This allows me to look at my monitors without needing to lean forward. I even have a keyboard surface that extends from my desk so I can pull the keyboard up to me when I'm sitting properly in my chair at my desk.
- I make pretty much all my fonts bigger in my browser, my text editor, and my terminal. This pretty much solves all my eye strain problems. My watch reminds me to breath every hour so I take that opportunity to close my eyes and relax for a minute.
I'd prefer this stuff was shunted off and centralized into some kind of moderation log, something like lobste.rs has. That also makes it easy for the casual user to get a birds eye view of the kind of links and stuff being removed, without having to go digging (i.e. helping to thwart the usual mod conspiracy dramas that boil over constantly, and also to help disincentivize abusive mods from encouraging conspiracy.. sadly also a not infrequent event)
The title is "Haskell is useless," but that's too troll-y to post here. There's a great summary over on lobste.rs which explains why I think this might be relevant to Rustaceans:
> Haskell has traditionally been safe but also useless, meaning that it’s free of side-effects (and what’s the point of a computer program that has no side effects?). He contrasts this with C, Java, C# which are unsafe but useful and points out that all languages are developing in the direction of safe and useful. For C/Java/C# this means going from unsafe to safe, and for Haskell it means going from useless to useful. To do this for Haskell, they’ve figured out how to keep side effects separate from pure code, and this concept has been slowly leaking back into C#.
It's hardly ever mentioned? Scala, Haskell, Elm, etc. are all functional programming languages and they are spoken about a lot here on reddit, on Hacker News, on Lobsters and other programming forums.
Most programming language discussions treat "functional" style as a benefit (see Reactive as an example) without a second thought.
In general, you'd have to qualify what you mean by "unpopular" or "looked over." If you just mean "has not supplanted imperative as a fundamental programming paradigm," then I would say that the answer is pretty complicated and due to the nature of the beast, there's not really any data so you're probably going to just get a bunch of opinions.
In general (from what I've heard over the years), functional programming is regarded as beneficial, but too complicated and slow to serve as a fundamental paradigm.
https://lobste.rs/s/nf3xgg/i_am_leaving_llvm#c_ubyrb0 <-- something everyone involved in open-source development needs to read, especially the fuckwits who lost their shit over FreeBSD's CoC.
Not that they'll learn anything from it, because they're white male supremacists, but at least they can't claim ignorance anymore.
Yes! I always hate when status reports or release announcements from projects don't include something like that, nor a link to a main page which describes it.
It's frequently the case that there's something of enough interest in such an announcement to submit it to a more general news aggregator like /r/programming or Hacker News or https://lobste.rs/, but people who come into it without context then have no idea what it's talking about.
I think that all progress announcements or release announcements should have at least a sentence or two about what the project is about, and a link to find out more. Regulars can easily scan over it to get to the meat of the announcement, while it helps provide context to people who haven't heard of the project.
Yeah, I expressed similar sentiments. The "array as a map" is a hack that really twists the benchmark into something a lot less useful IMO.
> From what I can tell the go solution just uses an array so this isn't hugely surprising.
Sure, but I never said otherwise.
What does "pleasing" mean? This question is too vague to have an answer.
I think it all depends on the application domain, which you haven't stated. My opinion is that all languages are domain-specific languages. A feature that is pleasing or useful in one context could be useless or harmful in others.
It also depends on the goal. A construct that helps you write fast programs may not be one that helps you write clear programs. Or it may not help you write a program that you can collaborate with others on. Design is about tradeoffs and different goals are often at odds.
Which Wikipedia articles about programming languages are good? I prefer to search through citations rather than Wikipedia. I posted a good survey paper here that people seem to like:
https://lobste.rs/s/j1hwab/research_debt/comments/8zekeh#c_8zekeh
I also re-read "Confessions of a Used Programming Language Salesman" by Meijer recently, and really liked it. It went over my head the first time around. (Some of it still does.) A lot of is a journey from Haskell to LINQ -- from "high culture" to "low culture", which I like.
Same response as elsewhere: check out more details about the library being bound.
In particular, problems in PHP do not shed light on the OCaml runtime any more than problems in Lotus 1-2-3 shed light on the OpenBSD kernel.
Many of the people there were more on the interested/curious side rather than being die-hards.
This also came up in the discussion of this on lobster.rs https://lobste.rs/s/9oq7ra/how_to_sell_excellence .
I'd add some nuance and say there are different types of "assholes". See e.g. Brilliant Jerks in Engineering, as well as this discussion about it. The story is mostly about jerks in engineering/software dev, the gist hold up fairly well in general.
I can't think of any use case for varargs (of heterogeneous type) that isn't printf / logging / etc.? I don't think I've encountered any in C or C++ code.
I know Rust implements printf with macros, and Zig uses compile-time metaprogramming (comptime). I'm not sure if either of them have varargs.
But anyway it seems like you don't really need it if you can express printf in a more general mechanism? I'd be interested in counterarguments.
If you don't have exceptions, I'd be worried about using multiple return values for errors, like Go. This article actually makes pretty good points, and the comment thread has some good ones too.
https://lobste.rs/s/yjvmlh/go_ing_insane_part_one_endless_error
I even noticed that C/C++ style "out params" and be more composable than multiple return values when one of the values is an error. It chains better and can be refactored.
A related issue is that Maybe is nicer because you don't have the value hanging around in the case when an error occurs. This happens in C/C++ code too though, i.e. if the caller didn't check a return value and used the out param.
var value, err = foo() # caller must not use value if err is false
To me, unsafe is about grepping for bugs/vulns. It is incredible that I can go to a library, search for "unsafe", and find an issue or not[0]. If you have a C++ dependency, so long as this is visible, you have the same 'power' - find the C++ code, start your audit there.
So to me unsafe is just a token to make it easier to grep. If I already know where to look for vulns, I don't need unsafe.
But then there's the "verify that the crate is safe" and that's kind of a different use case for Rust that seems very difficult to uphold, though seems aspirationally appropriate.
[0] Here's an example of someone just glancing at unsafe and quickly spotting a vuln. No need to audit the whole dependency. https://lobste.rs/s/9e7o8e/comparative_unsafety
Anyway, I appreciated this article. I think dtolnay's compromise is very reasonable. I don't think we should fret so much.
Another site that's trying to recreate the tech-focused vibe of HN is https://lobste.rs. It's invite-only at the moment but I can provide one if PM:d. I just want to know a bit about you to send an invite - github account, social media presence (Reddit is OK) etc. - so as to try to weed out spammers.
I'm interested in this too. I've been checking out Mastodon and I really dig it, but I generally prefer Reddit to Twitter, so it's not really filling the same niche IMO.
I wonder if there's any way that https://lobste.rs instances could be federated.
A comment by qbit at lobste.rs shows that NetworkManager in Linux has 841045 lines of code, but ifconfig(1) in OpenBSD has 5848 lines of code, so Linux has 143 times more code than OpenBSD to configure the network!
This doesn't count any code in the kernels of Linux or OpenBSD. Most of the auto-join code is in OpenBSD's kernel, in files like src/sys/net80211/ieee80211_node.c
Interesting. Must be the Baader Meinhoff effect, but this is the second time I'm reading an interpretation of a PL as an OS. The first one I read was here: https://lobste.rs/s/7oxlm4/i_do_not_like_go#c_yq5uyn (not lisp related)
One area where I think this would be really useful is constructing safe parsers.
In other words, if you express a parser as a CFG, you know that an algorithm to recognize it can be constructed in O(n^3) time. For LL(1) and LALR(1) (yacc), it's O(n), although yacc has semantic actions which will break this guarantee.
So basically I would like a linear time parsing language, to fix the semantic actions problem, and add to encompass more languages. I don't want a hard tradeoff between top-down and bottom-up parsing -- it should encompass both styles.
This relates to langsec: http://langsec.org/
(I think there are some problems with this research that I've mentioned elsewhere [1], but the general idea is useful.)
[1] https://lobste.rs/s/uyjzjc/science_insecurity_meredith_l_patterson#c_pzjzxh
Great, glad you found it useful! Actually I think we talked about this last week on lobste.rs:
https://lobste.rs/s/q3gmyi/what_are_you_working_on_this_week#c_zigv9g
(I am andyc there.)
I'm glad that someone else is working on this. I've wanted to work on it for over a year, but haven't been able to make it a priority, given all the other work. I look forward to any updates / blog posts on this experiment.
About unifying Lisp and ML: I know that /u/combinatorylogic is working somewhat in that area, although I haven't investigated the details.
I also got that sense from the Lux programming language, which was presented at Strange Loop:
The "modular compiler" stuff sounds like "putting most of the language in user space". I was a little skeptical because he threw it in at the end, saying "it will come real soon". I would rather have a demo than promises. But I believe the "modular compiler" and "unifying Lisp and ML" strands are somewhat related, and perhaps related to what you are thinking of.
This was discussed over on lobste.rs a couple weeks ago, and many people, myself included, noted a number of problems:
- The errors that can be caught by a type checker depends on the language and how the type system is used. For example, in OCaml writing to a read-only channel is a type error while in a language like Python it raises a runtime exception. Are these errors considered type errors or not in the study? We can rinse and repeat for things like
AttributeError: 'NoneType' object has no attribute 'foo', broken invariants, missing case in case analysis, etc. - These are the bugs that have been found; what about the bugs that are still lurking in those code bases, waiting for the right input to go down the execution path that raises a TypeError exception?
- A type error can trigger an exception other than TypeError; for example, if you have a dict with string keys and you forget to convert from a given object to string when doing a lookup in the dict you get a KeyError, but the real reason is that you tried to do a lookup with the incorrect type.
- The data from the Lutz paper is both old (2000) and doesn't use languages that have a modern type system (e.g. ML, Haskell, etc.) where it is common for programmers to take advantage of types to model a solution.
> I understand the need for money but my point still stands.
Your point applies to any version of Bitcoin, whether it's Core, Classic or Unlimited.
EDIT: apparently it doesn't stand.
Even if I didn't know some of the devs personally (EDIT: and didn't know this), I would still vastly prefer Core's Blockstream backing over Classic's backing by Coinbase.
Huh. I didn't think I'd ever hear about Lobsters on CB. Small world, or it's bigger than it appears. Probably the second one.
I was actually thinking about some stuff I've read on Lobsters while writing the OP. Irene's snark is stuck in my head.
I would really like to understand more general ways for taking the free type on a signature and cutting it down by laws. I walked through a similar process for Coyoneda a bit ago (https://lobste.rs/s/pz8rkp/abstractivate_from_lists_to_trains_to_functors/comments/f5sunm#c_f5sunm) but as far as I can tell right now it's always pretty ad hoc.
This is also my objection. You can require input, but you can't require quality input. (if you can programmatically determine the quality of a comment, there's no point in allowing users to vote at all...)
Additionally, this has been proposed numerous times here and in /r/ideasfortheadmins.
On the other hand, lobste.rs implemented this -- however I don't think it's possible to really see it in action without loging in, which requires an invite.
Another unusual lobste.rs feature:
> If users are disruptive enough to warrant banning, they will be banned absolutely, given notice of their banning, and their disabled user profile will indicate which moderator banned them and why. There will be no "shadow banning" or "hellbanning" of users.
The problem with this: when you tell spammers they've been banned, they just re-register. Shadowbanning keeps them wasting their time with nonfunctional accounts instead of re-registering. However, lobste.rs combats this by staying small, and having a strict invite-only system in which users who invite spammers can themselves be banned. This unfortunately adds a very high barrier to participation; I think sites like reddit see shadowbanning as a small price to pay to keep registration burden low.
Why great? Their GitHub landing page says: > This is the quite sad source code to the ghost town at https://lobste.rs.
What have they come up with, that demonstrates an improvement over status quo methods?
Well said!
OK, yes, as Btrfs subvolumes it might work.
Sharing an ESP partition is the right thing to do. I think sharing one BIOS_BOOT partition on an MBR partition is probably OK.
But sharing one /boot partition on a normal filesystem is not going to work, AFAICS.
Although kernels are usually versioned in the filename -- e.g. vmlinux-5.3.18-59.19-default.gz -- normally the default one is always called vmlinuz (for obscure historical reasons) on all distros.
Having 1 shared kernel but all expecting different root filesystems Will Not Work, I think, and will fail badly.
> I'll give you 4, not 2. MongoDB, Confluent, CockroachDB, Redis Labs. Bonus: Sentry
redis and mongo are under the influence of the same bain capital fuckhead.
confluent does the same thing as AWS: they do professional services and host kafka. idk why you even mention confluent as it is a perfect counterpoint to AWS being the big bad.
the AWS managed kafka is simply worse than confluent's and thus they do pretty good business.
> You should read more, infact Grafana changed to AGPLv3
stop telling me to read more. it's pissing me the fuck off.
at least you got the license change correct this time.
agpl3 isn't hostile to open source. elastic's license change is.
> Because they do less and profiteer from Elastic's Free products, it is not just with ES but they also have done with Kafka, Mongo, Redis. Infact, AWS would have done the same with Grafana, but they realized it is a slippery slope, and started collaborating AWS Managed Grafana!
you....have no idea, do you?
> https://lobste.rs/s/qtsjh1/elasticsearch_does_not_belong_elastic#c_hbttgr
not only does this disprove the claim that AWS was not contributing back but it proves my point that elastico is taking a ball that isn't even fully theirs and going home.
elastico built a business off of other people's contributions and they have the goddamn audacity to complain about amazon?
lmao
Even if proc macros were cacheable etc... they would still cause compile times to slow down because all macros slow down compile times by a bit.
Look at how much latency the built-in std derives can add for medium and large scale projects (read some of the follow-up comments for more extrapolated stats): https://lobste.rs/s/6y5waa/rust_compiler_isn_t_slow_we_are#c_c88zaq
This patch removing a bunch of macro_rules! macro trait derivation caused sled's compile times to drop by almost 20%: https://github.com/spacejam/sled/pull/1131/files#diff-d0e9b1d1df1c5795eac22a324e40477eL586-L838
At least you can disable optimization passes when building the proc macro during release builds though: https://github.com/flamegraph-rs/flamegraph/pull/89/files#diff-80398c5faae3c069e4e6aa2ed11b28c0R30-R31
> but for me, it is hard to understand.
Curios, do you have experience with Java or C#? I feel that the distribution of people talking about IDE support is bimodal:
- some folks are deeply familiar IntelliJ/Resharper, and they find IDE support in lesser ecosystems nonexistent
- some folks haven’t used the few existing smart IDEs, and, more or less, don’t realize what they are missing (https://mobile.twitter.com/rust_analyzer/status/1268214493835939841, https://lobste.rs/s/vjymsq/syntax_highlighting_is_waste#c_uunjlw being a couple of recent examples).
Thanks, updated mine as well :)
I agree with your point that there’s ample prior art, used in production already. In particular, IntelliJ has been doing this for a long while (some specific examples here: https://lobste.rs/s/vjymsq/syntax_highlighting_is_waste#c_uunjlw)
Lobste.rs does. I think many newer ones do.
As a moderator that easily gets harassed, I think having a specific mod singled out is a bad idea. It leads to more targeted harassment of an individual.
> Try looking at https://github.com/samueldr/wip-pinebook-pro and https://github.com/Thra11/nixpkgs-overlays-rk3399 try asking on freenode #nixos-aarch64.
Thanks! I’ll check those out.
> Also remember that a PineBook and a PineBook pro have different chip sets and need different drivers (Allwinner A64 vs Rockchip RK3399)
Great point, I wasn’t aware of this. In fact I was only vaguely aware of the Pine64 project until I came across this lobsters post about the PineBook Pro. I’d been wanting a Linux laptop, so figured it’s worth a shot.
I think any of the languages would be fast enough, and all things being equal, I would choose the more productive one. And I agree D is interesting because it has garbage-collected data structures.
I had an exchange with someone interested in D here, and I posted my thoughts:
https://lobste.rs/s/glocqt/release_oil_shell_0_7_pre1#c_tkr0si
Basically the idea is that I'm going to work on automatic translation to C++. But it's possible that will fail or be subpar, and it would be nice to have other people pushing in parallel on a different codebase.
You would get a big "leg up" as I described in that post, because of all the DSLs.
Clojure has edn: https://github.com/edn-format/edn
Types are problematic in a distributed setting because they require a global view of the program. You can't upgrade an entire distributed system all at once. (If you can, it's a small system.)
Protocol buffers are sort of a pseudo-type system that are designed to solve this problem. (The RPC/IPC systems that other companies use like Thrift and Avro are more or less based on Google's protocol buffers.)
See Rich Hickey's "Maybe Not" video here and my comments with respect to protocol buffers / type systems in distributed programs:
https://lobste.rs/s/zdvg9y/maybe_not_rich_hickey
Shipping code like lambdas is also a problem. In big systems you can't assume that every node is running the exact same version of the runtime. Otherwise how would you upgrade the runtime itself? There is no atomic upgrade. Upgrades must be done in a rolling manner with backward compatibility.
I mean, I made the same mistake and I kind of regret it. I though medium helped me "get popular", but as soon as I stopped posting on forums my articles and relying only on my followers on medium... I realized they are essentially a hallow number.
​
As an example, a story I wrote yesterday at about the same time, and have not shared anywhere, has 18 views as of right now.... despite me having over 800 followers on medium.
​
This story has 25 views, but ~10 of them seem to come from this subreddit.
​
Usually I would get 10k-100k views per article, and assumed some of it is a boost from medium advertising my story to relevant demographics, but once I looked into their practices around free-stories and experimented with not posting my stories in publications and/or on reddit I realized all the traffic was just coming from reddit (and lobste.rs, hackernews... etc)
I was actually going to stop responding as we clearly aren't getting anywhere, but I just saw an article on lobste.rs about How VT-x, KVM and QEMU Work Together
It had a great quote!
> When in non-root mode, CPU-bound code mostly executes in the same way as it would if running in root mode, which means that VM’s CPU-bound operations run mostly at native speed.
very cool! :)
Have you heard of invitation-based forums? When troll or spam accounts appear, you can implicate the account that invited them.
A site that I view quite often employs this method:
>Invitation Tree
>New users must be invited by a current user, though there is no formal vetting process. Invitations are used as a mechanism for spam-control and to encourage users to be nice, not to make the Lobsters userbase an elite club. The most efficient way to receive an invitation is to talk to someone you recognize from the site or request one in chat.
>The full user tree is made public and each user's profile shows who invited them. This provides some degree of accountability and helps identify voting rings.
>There's no limit on how many invitations a user can send (though that might be prompted by scaling problems in the future). When accounts are banned for spam, sockpuppeting, or other abuse, moderators will look up the invitation tree to consider disabling their inviter's ability to send invitations or, rarely, also banning.
This is very cool, but note that it is a microbenchmark comparing the overhead of calling plus(int, int). This is a very specific case of FFI that is easy and simple.
For my work on the Oil shell, I care more about moving strings back and forth across the VM boundary (not to mention bigger objects like records and arrays of records). There are many more design choices in that case, and I suspect the results will also look different.
(copy of lobster.rs comment )
> Although I am afraid that mETH huffers will read it as an endorsement of Casper and Ethereum. They should not.
Bit of a slap-fight developed over this on lobste.rs, leading one of the resident True Believers to stomp off up to his room.
lobste.rs is actually exactly such a site. It's geared towards programming/software development talk, but it's open source, so theoretically anybody can set up their own server and make a similar platform for a different subject matter. (People have, in fact.)
I am discovering Rust through the aoc (/r/adventofcode) and have a question related to lifetimes inside closures.
Consider the following snippet taking a standard input to parse it, and hoping to create a Vec<Vec<String>>: > let stdin = io::stdin();
> let input = stdin.lock().lines().map(|line| line.unwrap());
> let input = input.map(|line| line.split_whitespace());
The third line triggers the following error:
> line does not live long enough
After a bit of digging, I essentially understand the problem. As described here, intermediate bindings have more semantics than in traditional languages in that they enforce a longer lifetimes to bound resources. In particular, I understand that precisely for this reason, the two first lines of my snippets could therefore not have been mashed together since we need to make clear to the compiler that the io handler must survive beyond the lock one.
However I do not understand how to handle the question when inside of a closure, as in the third line, where an expression is expected.
Any help or pointers are welcome. Thanks!
I've been answering similar questions in this thread on lobste.rs. I will definitely add a comparison page to the docs soon!
Here are some highlights from that thread:
- Celery doesn’t support task prioritization. You have to deploy multiple sets of workers in order to prioritize queues. Dramatiq lets you prioritize down to the individual actor level
@dramatiq.actor(priority=x). - Celery has poor support for delayed tasks. Delayed tasks go on the same queue that normal tasks go on and they’re simply pulled into worker memory until they can be executed. This makes it hard to autoscale workers by queue size. Dramatiq enqueues delayed tasks to a separate queue.
- Celery acks tasks as soon as they’re pulled by a worker by default. This is easy to change, but a bad default. Dramatiq doesn’t let you change this: tasks are only ever acked when they’re done processing.
- Celery tasks are not retried on error by default. Dramatiq retries with exponential backoff by default for up to 30 days.
- Celery’s not well suited for integration testing. You’re expected to unit test tasks and to turn eager evaluation on for integration tests, but even then task exceptions will be swallowed by default. Dramatiq provides an in-memory stub broker specifically for this use case.
- The source code is spread across 3 different projects (celery, billiard and kombu) and it’s impenetrable. Its usage of runtime stack frame manipulation leads to heisenbugs.
- It’s easy for some of its more advanced “canvas” features to drop tasks.
> The quality doesn't get worse, you just live long enough to see everyone repeating the same tropes over and over
Clicked on that link, the very first post is about switching from X language to Y language. Too true, too true.
Paraphrasing https://lobste.rs/s/dwzplh/krack_attacks_breaking_wpa2#c_pbhnfz :
> No worries. We will likely still patch on time of public announcement anyway. We just cannot patch problems we don’t know about yet. > >What happened is that he told me on July 15, and gave a 6 weeks embargo until end of August. We already complained back then that this was way too long and leaving people exposed. > >Then he got CERT (and, thus, US gov agencies) involved and had to extend the embargo even further until today. At that point we already had the ball rolling and decided to stick to the original agreement with him, and he gave us an agreeing nod towards that as well. > >In this situation, a request for keeping the problem and fix secret is a request to leave our users at risk and exposed to insiders who will potentially use the bug to exploit our users. And we have no idea who the other insiders are. We have to assume that information of this kind leaks and dissipates pretty fast in the security “community”. > >We chose to serve the needs of our users who are the vulnerable people in this drama. I stand by that choice.
Also, coordinated disclosure is bad for projects like OpenBSD, because the "insiders" (NSA?) may abuse the bug before it's disclosed. OpenBSD does not stand by this and protects its users, period.
Thanks for clarifying, several people have mentioned this, including over at lobsters https://lobste.rs/s/wb7fdm/lifelong_rubyist_makes_some_python_code which I hadn't even considered could be a possible interpretation, but would have been very impressive. My question to the original commenter "what were you hoping for when you clicked on this" was a genuine question. Thank you for taking the time to answer.
Do you think perhaps "Lifelong Rubyist makes a Python script 5x Faster" is better? Or that's still ambiguous.
At the least I added a note early on to help clarify things earlier hopefully.
> Several people have mentioned they thought the post was about me making the Python interpreter faster. That would have been pretty dang cool, but is not the case. This article is about how to write faster code using an interpreted language.
hey, i'm not a member there but you could try their IRC channel (#lobsters on freenode), as suggested here: https://lobste.rs/chat
also you can request an invite publicly here: https://lobste.rs/signup / https://lobste.rs/invitations/request
good luck :)
> if the user doesn't know about cryptography, he might shoot himself in the foot.
why then does the crypto community hate JWT https://lobste.rs/s/dkk1ny/things_use_instead_jwt#c_lgpbs0
> the server can generate JWT to keep some state client-side safely.
the article contains several options for storing state on the client side that are all better than JWT
This is really very cool. I submitted it to Hacker News and Lobste.rs as it deserves the views, hope that's OK.
I also run a mailing list for web automation, would you be interested in doing a short interview about that part of the project in more detail?
> So, hmm, why did you guys choose React in the first place?
There seems to be a confusion here that I must somehow be affiliated with the authors of the article. I just found it on Lobsters. But I do approve!
Would this be similar to what you're looking for https://lobste.rs/ ?
There's also http://meta.telescopeapp.org/ which has voting capabilities and the threads can be sorted by Top New Best Daily
Both are open source and would probably be easier to set up than Reddit.
I haven't looked into the code of it yet, but there's also a site called https://lobste.rs which runs on Rails and is supposed to be really well done. The repo to their code is here: https://github.com/jcs/lobsters
Only thing that bothers me is I can't see downvotes there so how are we supposed to downvote fuccbois into oblivion? Haha
It is said by people more achieved than me and who I take for granted stand in a position better able to judge: Depends how good a C programmer. in general, yes.
I don't know about numpy arrays.
Here is where the rabbit hole that got me to have some enjoyable experiences started: https://lobste.rs/s/smjvxx/impending_kos
+1 for code as craft and high scalability. two of my favorites.
Also if you're not already following hackernews or lobsters, they're also good:
Came to this sub to rant about HN no longer being about 'hacking', was pleased to discover this thread.
As a comparison, read the comments over at lobste.rs.
PM for an invite to lobste.rs if you want to escape the cesspool of HN.
Well I'd say Rust has an ecosystem already -- it has many people writing Cargo packages, lots of docs, etc.
But Rust doesn't have a native platform, in the way that C, C# or Objective C do.
If Fuschia takes off, and Rust is the language of Fuschia apps, then that would be an example of the effect I'm talking about. The popularity of the platform (like Unix, Windows, or the web) drives the popularity of the language.
But I'm not sure if
- Are Fuschia apps naturally written in Rust? The thing that makes C sticky is that the kernel interface is defined in terms of header files, so your app needs to consume C to be written on that platform!
- If Fuschia will become popular. I haven't been following it, but I think the motivation is something regarding a stable binary interface for drivers, which Linux doesn't have. (Also, the reasons Linux doesn't have that seem compelling to me, but I know relatively little about kernel/driver/hardware issues.) It feels like it will have to be something vendor neutral like Linux to get broad buy-in from hardware vendors (Intel, IBM, etc. all of whom pushed Linux as a competitive threat to Microsoft)
So yeah unfortunately language adoption is tied to platform adoption, which is caught up in the politics of big companies.
For another viewpoint on that, see this history of the X window system which I just posted:
https://lobste.rs/s/s3l7rc/political_history_x_keith_packard_lca#c_ruim3a
I didn't realize it, but the whole reason X exists is that 3-4 decades ago, a lot of competitors to Sun didn't like that Sun owned the standard for GUI applications on Unix.
Those two NixOS does with almost unparallel excellence.
The curse of NixOS is exactly that it does several things very well, but it clunky in some others: https://blog.wesleyac.com/posts/the-curse-of-nixos (discussion: https://lobste.rs/s/psfsfo/curse_nixos)
Ah glad I found someone to report my issue. I think it fails to correctly retrieve my DKIM pubkey, which is split in multiple chunks enclosed with ".
I don't know if that's an issue with the site, or if my dns record is incorrectly formatted, but eventually picked up correctly by some other testers (namely mail-tester.com).
You can PM if you want more details like domain and dkim selector.
I'm no neuroscientist, but I did research to aid my own problems, if information would be more accessible, more people would experiment, and we'd have more data to guide us.
I'm surprised nobody built a publicly accessible graph like this before (and more importantly, a website with it that enables a curated set of people to add links and nodes).
The author responds to this kind of sentiment here https://lobste.rs/s/1wrjdy/rewriting_libimagequant_rust_for#c_agnfi1
​
You may or may not find it compelling.
Yes absolutely! Header files are IDLs for binary interfaces :)
COM took that to the next level. It has problems but I think there is some value there.
I wrote about that here, and the rest of the thread has some interesting comments about Win32 being the most stable ABI for Linux games! I'm not in the gaming world but that's apparently a recent evolution / popular opinion.