-
It’s even easier when using ii from suckless. We have a bot on #openbsd-gaming now that reports how many people are currently playing. It just runs
qstatevery 5 minutes, massages the output and spits it out to the input file tied to our channel. It’s hard to beatecho "hello world" > irc/chat.freenode.net/#openbsd-gamingfor scripting bots.-
This is like some weird Portlandia thing…“The dream of Plan9 is alive in suckless”, etc.
Still, neat though! :)
-
-
-
ii sounds great in theory, but try to answer new incoming queries. now instead of parsing a single stream of text you have to monitor an entire directory tree with files appearing out of nowhere at any time
Sure, if your bot needs to respond to private queries. The one on our channel doesn’t parse any input at all. Including the channel itself - it’s a notification bot.
parsing irc is super simple and ii is a retarded idea for a bot
You’re telling me it was retarded to output the result of
qstatevery 5 minutes to a file? It took 5 minutes to write the notification usingii- it serves it’s purpose.Does
iifit every use case of writing a bot for IRC? Nope. However it does make it dead easy to have various tools output content to a file and get it delivered on an IRC channel that way.-
To be fair, even for notification, it seems overkill to pull
iiand play with files when you can simply send to socket:NICK bot JOIN #foo PRIVMSG #foo :My text messageAll you need is
echoandncand IRC is yours.iilook to me like an overkill solution for simple problems and limited solution for complexes ones. But then I might simply be missing some complexity about writing bots, manager server configuration, connection throttling, etc.-
Sure, but you will either connect to the network each time you invoke that notification or will need to maintain the connection up, respond to keepalive pings from the server etc. It is really easier to just dump a notification to a file every 5 minutes and have
iihandle the connection.It’s not perfect for all use cases, but it does simplify this specific one we had :)
-
-
-
-
-
-
As someone currently writing free monad code for something that could probably just be dependency injection, this hit a bit too close to home.
-
It’s been a while since I did any Rust, but I remember the compiler giving similarly useful error messages. Bad error messages are easy to overlook until you experience how good they can be.
-
Definitely something I’ve been bit by in the past and will comment on in code review. My general rule is no
_for pattern matches on user defined ADTs (since they may be extended in the future). Fine with it for builtin types because they often aren’t extensible.Un(but almost)related nit. Hate it when people use
_to avoid explicitly typing the final variant of an ADT.
-
- Domain: go to market, prototyping, early validation, tech stack
- Location: Warsaw/Online
- How to get in touch: http://generativestuff.com/sparring/
- Notes: free one hour sessions for early stage projects!
-
-
-
I did a quick rain-check on the IRC channel if such a post is okay with us - all I got was one thumb up. But myself I wasn’t sure if this would fly. My only line of defense is that I guess we could both agree that there exist more powerful and direct ways of self-promotion.
-
-
disconnected - the graph is made up of sub-graphs or it is bipartite.
Just a small correction, but a bipartite graph can be connected. Here’s an example of a bipartite connected graph.
-
-
edit: That graph is connected because there is a path from every node to every other node. Wolfram alpha does a good job visualizing all the different connected bipartite graphs of size n (for small n’s) at the bottom of the page here.
When the path from every node to every other node is a unique edge, then you have a complete graph.
-
-
-
-
If we do this we should also rename
mltoml-languageso that people don’t continue to misfile it.((metalanguage-language!)
-
-
That example for the threading macro could go either way, I certainly wouldn’t consider it crappy.
Definitely possible to go overboard with threading. I often find it neatest to thread certain subexpressions in an expression that could otherwise be fully threaded because it makes the ‘core’ semantics of the operation clearer.
-
You can’t determine if a link is a universal link for a given user (which requires them having the associated app installed on their device), but you can tell if it supports universal links by checking a domain for an
apple-app-site-associationfile (e.g. http://google.com/apple-app-site-association).This could allow a privacy conscious mobile browser to conservatively remove links that support universal linking, regardless of whether or not they would have opened a native app if clicked on that user’s device.
-
For a long time I felt similarly with respect to Haskell being a poor fit to domains that require a lot of “io plumbing”. Certainly you lose a lot of the pleasantness given to you by an expressive static type system when most of your application logic consists of handling third-party input and performing simple transformations on said input.
That said languages like Haskell make it easy to write good abstractions, around ugliness like that. If done right, it can be -very- easy to extend the input handling functionality without making it feel like you’re playing the “read who knows what and get it into the form of a application specific ADT, handling errors cleanly” game.
Just a couple of days ago I added a feature to a Haskell project I hadn’t touched in years that allowed it to parse a completely new type of binary message over the wire. It was as easy as adding a value constructor to an ADT and updating some pattern matches that the compiler could detect were no longer exhaustive.
-
Sweet landing page, very polished.
Funny opening with “A powerful language for building scalable systems on the JVM” followed by (can’t say for sure without checking the compiled output) what looks like a terribly unscalable implementation of “quicksort”.
-
-
Doing it in-place would be ideal. Here’s an example of an efficient variant of quicksort:
But I don’t mind seeing the naive quicksort implementation. It’s not algorithmically optimal but it’s very easy to understand.
-
-
-
Has anyone read this book before? Is it any good?
-
Friends don’t let friends use bitmasks when they could have just used an extra element in the (arguably) simpler earlier versions. Depending on the size of each element I’d prefer simpler code. Plus the no mask versions are basically a design pattern that many programmers are familiar with so it should be somewhat self documenting.
-
-
[Comment from banned user removed]
-
Please, let’s not turn Lobste.rs into Reddit with threads of tired old witticisms, eh? It adds no value to the discussion.
-
-
-
-
Inefficiency is a common critique of functional programming. I dislike that simplified quicksort example because it appears to reiterate that idea.
-
Link to previous Lobste.rs conversation about this https://lobste.rs/s/vhkucf/illegal_numbers
-
-
I liked the bit about the new
?operator. A convincing argument for when something should be turned into a language built-in (in my opinion).-
I’m concerned with how subtle it is. It took me a while to figure out the revised code because I just didn’t see the first ?. I saw the second, but couldn’t figure out how it worked.
Maybe rust isn’t C, but I’ve never liked control flow macros. I get nervous when I can’t see all the ways out of a function.
-
I really like the new operator - but I can understand that people might find it too invisible when glancing at a codebase.
The big benefit of
?compared tothrowof other languages (C++, Java) is that it the underlying concept (Result<T>) forces you to handle the possibility of errors in every layer. Compared to C or Go (both force you to think about addingif err != nil { return err; }).So compared to Java/C++ it’s more obvious where errors can happen and compared to C/Go it’s forcing you to handle errors where they happen (just ignoring a
Resultwill result in a compiler warning). -
I’m concerned with how subtle it is.
But isn’t that the intention? The idea is that it looks like you’d write code almost as if errors don’t exist, while giving the possibility to let errors bubble up. I agree that it hides errors to some extend, but the same is true for checked exceptions or error monads.
-
-
I share your overall unease with hidden function-exits and would recoil at seeing things like break/continue/goto/return in a macro, but I don’t think all control-flow macros are necessarily bad (e.g. the Linux kernel’s
list_for_eachor the analogoussys/tree.htraversal macros in BSDland).
-
-
-
HKT and do notation has a number of unresolved questions in Rust, ones that might take years to be resolved, if ever.
The need to make error handling is immediate and affects most Rust users.
If that ends up being a wart on the language in years, well, at least everyone’s life will be improved between now and then. rust will never be perfect.
-
-
-
How could it be more powerful than it is? Please explain, you really got my attention :D
-
-
At first glance, I really like it. I code mostly backends in Erlang/Elixir. One of the biggest issues of my code is having nested cases (match in Rust or OCaml). Elixir somehow got it solved with the with special form. The RabbitMQ team created Erlando using Erlang’s parse transform (sort of macros) that adds syntax extensions to Erlang, with the do syntax for monads being the most important one to solve somehow this issue.
Is there any other way of solving this issue? Is there any other concept that solves this type of problem that is not somehow related to monads?
I ask this since the last years it appeared to me that in the end if I don’t have support or tools similar to do notation I keep on reiventing the wheel or non standard tools like Erlando or semi powerful constructs like Elixir with.
-
-
-
Does anyone know if a dictionary implemented in a low-level language like Rust/C/C++/D/Go, and using the same compact/ordered structure, would have the same benefits?
-
It seems likely. Most of the benefits discussed in the pypy blogpost about it don’t have anything to do with Python (GC friendliness is the only one that does, and that would probably also affect Go and D depending on the details of their GC).
-
Interesting. FWIW, Go intentionally “randomises” map iteration order (this was introduced after people started relying on a stable iteration order).
-
Which results in people relying on the order being randomized instead.
-
Users are the worst.
-
-
-
-
-
-
I get that core/async Clojure code follows the Go channel example fairly close, but it seems misleading wrt the actual problem of starting two expensive computations and aggregating their results.
This can be done in Clojure using futures as succinctly as it’s shown to be in Scala.
Yup, Scala example could be translated directly as: