archived stringclasses 2 values | author stringlengths 3 20 | author_fullname stringlengths 4 12 ⌀ | body stringlengths 0 22.5k | comment_type stringclasses 1 value | controversiality stringclasses 2 values | created_utc stringlengths 10 10 | edited stringlengths 4 12 | gilded stringclasses 7 values | id stringlengths 1 7 | link_id stringlengths 7 10 | locked stringclasses 2 values | name stringlengths 4 10 ⌀ | parent_id stringlengths 5 10 | permalink stringlengths 41 91 ⌀ | retrieved_on stringlengths 10 10 ⌀ | score stringlengths 1 4 | subreddit_id stringclasses 1 value | subreddit_name_prefixed stringclasses 1 value | subreddit_type stringclasses 1 value | total_awards_received stringclasses 19 values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
null | [deleted] | null | [deleted] | null | 0 | 1491162120 | False | 0 | dfqm73h | t3_62yl50 | null | null | t1_dfqm535 | null | 1493734596 | 1 | t5_2fwo | null | null | null |
null | Anon49 | null | Enemies will receive your actions late. You will receive their RE-actions even later. It will be "fair", but it will feel like shit. Its like increasing everybody's ping.
What games do you play so I can make up a good example? | null | 0 | 1491162121 | 1491162389 | 0 | dfqm74n | t3_62yl50 | null | null | t1_dfqm535 | null | 1493734597 | 2 | t5_2fwo | null | null | null |
null | [deleted] | null | [removed] | null | 0 | 1491162451 | False | 0 | dfqmf5a | t3_631b1q | null | null | t1_dfql3nv | null | 1493734703 | 1 | t5_2fwo | null | null | null |
null | saevarb | null | No, that would not be a more accurate statement. The concept of monads is literally a set of things and some operations. One of those operations is the bind operation. This operation basically explictly models "running some computation and then passing the result on to the next computation" .. which is exactly what imperative code is. The IO monad is not the only thing that is imperative. This goes for Maybe and any other Monad.
Whatever happens after you compile to something else and run it is completely irrelevant.
EDIT:
> Pure Haskell and imperative IO commands don't "coexist in a language" as much as it's one language used to define statements for another. What I'm saying isn't even controversial, it's simply how Haskell works.
Somehow I forgot to address this. I'm sorry, but this is just nonsense. Maybe you should learn Haskell before making statements like that.
| null | 0 | 1491162464 | 1491163103 | 0 | dfqmflz | t3_62yl50 | null | null | t1_dfqlr03 | null | 1493734710 | 22 | t5_2fwo | null | null | null |
null | WittyAdrian | null | Ahh, that makes sense. I've started CS:GO recently which is probably a great example where reaction time is crucial. | null | 0 | 1491162511 | False | 0 | dfqmgw3 | t3_62yl50 | null | null | t1_dfqm74n | null | 1493734727 | 1 | t5_2fwo | null | null | null |
null | WittyAdrian | null | Ahh that's a good point, I hadn't considered that. I'm definitely getting a better understanding of these concepts though! | null | 0 | 1491162587 | False | 0 | dfqmis6 | t3_62yl50 | null | null | t1_dfqm6az | null | 1493734753 | 3 | t5_2fwo | null | null | null |
null | kenmacd | null | Nope, sorry, that might be your definition, but 'flooding', which is called a volumetric attack, is a very small subset of what constitutes a DoS attack.
DoS attacks can be created with a single packet. | null | 0 | 1491162722 | False | 0 | dfqmmca | t3_62ul90 | null | null | t1_dfqcsyt | null | 1493734800 | 1 | t5_2fwo | null | null | null |
null | FenrirW0lf | null | Rust's memory management is more like C++'s than C. It uses RAII and destructors and the like rather than requiring explicit freeing of memory or other resources. | null | 0 | 1491162782 | False | 0 | dfqmnyr | t3_62wye0 | null | null | t1_dfpq9un | null | 1493734822 | 1 | t5_2fwo | null | null | null |
null | WrongAndBeligerent | null | Would you say though that a lot of the design of that program was based around pointers to objects and the classic C++ "OO" style design?
I notice something similar when dealing with C# - every instance of a class can be null, and everything that can be null is an opportunity to crash. The result ends up being null checks seemingly everywhere. In the C++11 that I have total control over, nothing is done that way and there is nowhere that I have a data structure full of pointers to anything.
I think Rust has a lot of value in this situation, but I also think that the fundamental solution is avoiding designs like that in the first place. Of course a language that makes the person check for null if they go down that road is great too.
While everyone thinks "what language do I want to write this in?" I think an equally important question is "what language do the people who would use this want it to be written in?" | null | 0 | 1491162867 | 1491485032 | 0 | dfqmq9e | t3_62wye0 | null | null | t1_dfpsavo | null | 1493734852 | 3 | t5_2fwo | null | null | null |
null | Tarmen | null | Well, we could look at a data structure as a tree. You have a references as spine and the data in the leafs.
Generally the untouched leafs and spines will be shared. Updating a lot of entries still can be really expensive, though, because you are constantly walking in and out of the structure. There something like a zipper can help, which lets you walk into the structure once and then allows you to do as many changes as you want in O(1) each. Only when you require the whole structure at once do you need to rezip it. | null | 0 | 1491163005 | False | 0 | dfqmtud | t3_62yl50 | null | null | t1_dfqikw1 | null | 1493734901 | 2 | t5_2fwo | null | null | null |
null | tophat02 | null | Nit: even though your syntax isn't finalized, it'd still be great to see examples in the readme (as one of the first things you see). | null | 0 | 1491163030 | False | 0 | dfqmui3 | t3_631p99 | null | null | t3_631p99 | null | 1493734910 | 37 | t5_2fwo | null | null | null |
null | htuhola | null | I always roll out the initial commit when I see a new programming language. This got one on Jul 7, 2016. | null | 0 | 1491163140 | False | 0 | dfqmxdz | t3_631p99 | null | null | t3_631p99 | null | 1493734948 | 3 | t5_2fwo | null | null | null |
null | [deleted] | null | [deleted] | null | 0 | 1491163299 | 1491164891 | 0 | dfqn1px | t3_62hu4c | null | null | t1_dfn8olm | null | 1493735006 | 1 | t5_2fwo | null | null | null |
null | lpuig | null | Probably, but comparing it with live cost, it's not probably the best balanced option. | null | 0 | 1491163336 | False | 0 | dfqn2nk | t3_62zrgk | null | null | t1_dfq940u | null | 1493735018 | 2 | t5_2fwo | null | null | null |
null | rabbyburns | null | My biggest concern with dropping it into an existing language without higher level abstractions is largely related to flow control and dependency management.
Sure, server.file('/foo') looks great, but how do you handle a dependency on that resource in a completely different module?
In puppet, I'm able to force an apt-get update before any package installs. I would expect either a need to be very opinionated on how I deal with those scenarios or be limited to a imperative style of implementation. The biggest power of puppet/ansible/salt, to me, is being better able to ignore specific ordering constraints.
I'd be interested to dig into chef more to understand how they manage this. If I'm ever put in a position to use another CM (obviously I'm in a puppet house at the moment) I'm most interested in trying salt, though. | null | 0 | 1491163423 | False | 0 | dfqn513 | t3_61e7ja | null | null | t1_dfhdvm0 | null | 1493735050 | 1 | t5_2fwo | null | null | null |
null | WrongAndBeligerent | null | It doesn't have to be with folding in the editor. | null | 0 | 1491163427 | False | 0 | dfqn55b | t3_62z7p7 | null | null | t1_dfqfbqq | null | 1493735051 | 4 | t5_2fwo | null | null | null |
null | myrrlyn | null | /r/dlang is that way.
Rust had a GC; they dropped it specifically because they didn't want to deal with the costs of a GC.
(Note: I'm not bashing D. If you want a C-like language with a GC'd heap, you want D, not Rust. D can even link to C++ code; good luck doing that in any other language) | null | 0 | 1491163509 | False | 0 | dfqn7db | t3_62wye0 | null | null | t1_dfpy54r | null | 1493735081 | 2 | t5_2fwo | null | null | null |
null | gingerbill | null | What type of examples would you like to see? | null | 0 | 1491163520 | False | 0 | dfqn7pf | t3_631p99 | null | null | t1_dfqmui3 | null | 1493735086 | 5 | t5_2fwo | null | null | null |
null | [deleted] | null | [deleted] | null | 0 | 1491163577 | False | 0 | dfqn95w | t3_631p99 | null | null | t3_631p99 | null | 1493735105 | 8 | t5_2fwo | null | null | null |
null | tophat02 | null | Pretty much any non-trivial example that shows me what it looks like right now. Maybe a minimal GL program? People tend to shop for languages by syntax. Right now it takes 4 or 5 clicks to see the language. | null | 0 | 1491163676 | False | 0 | dfqnbuv | t3_631p99 | null | null | t1_dfqn7pf | null | 1493735140 | 23 | t5_2fwo | null | null | null |
null | LtAramaki | null | > This operation basically explictly models "running some computation and then passing the result on to the next computation" .. which is exactly what imperative code is. The IO monad is not the only thing that is imperative. This goes for Maybe and any other Monad.
I'm unsure if you're explaining it poorly, trying to bend words to fit your narrative, or you don't use Haskell, but the imperative computation defined by an IO type doesn't occur while you're calling bind on it.
Binding merely adds actions onto the monad (more accurately returns a new monad with the new action added), like pushing successive statements on a stack. These statements aren't executed until you return an IO monad from your main function.
To quote the [Haskell manual](https://wiki.haskell.org/Introduction_to_IO):
> Ordinary Haskell evaluation doesn't cause this execution to occur. A value of type (IO a) is almost completely inert. In fact, the only IO action which can really be said to run in a compiled Haskell program is main.
The imperative program you've thus built in your IO monad is then executed *after* your main function has finished executing. The functional and imperative aspects of Haskell should be considered two completely distinct parts of the runtime.
`Maybe` doesn't work like IO at all. It's utilized entirely within the functional Haskell code as-is, not interpreted by a routine that reads off `main` or anything like that. And calling `Maybe` "imperative" is extremely sketchy and I have no idea what are you hanging onto for this conclusion. Most people who have a clue what `Maybe` is won't agree with you. | null | 1 | 1491163747 | 1491164085 | 0 | dfqndtv | t3_62yl50 | null | null | t1_dfqmflz | null | 1493735167 | 0 | t5_2fwo | null | null | null |
null | UnreasonableSteve | null | Yep, they switched it a year or two back I believe.
https://i.imgur.com/65Aibys.png | null | 0 | 1491163841 | False | 0 | dfqnght | t3_62vx64 | null | null | t1_dfqjbkq | null | 1493735203 | 2 | t5_2fwo | null | null | null |
null | bumblebritches57 | null | I mean a pointer to a struct like in C.
> a low level data structure
What does that even mean? what's a high level data structure. | null | 0 | 1491163860 | False | 0 | dfqnh16 | t3_62wye0 | null | null | t1_dfql71w | null | 1493735211 | 1 | t5_2fwo | null | null | null |
null | MINIMAN10001 | null | To do UDP in the browser your only choice is currently WebRTC. This pulls in a stack [info on this page](https://hpbn.co/webrtc/)
A data channel stack consists of SCTP, DTLS, ICE/STUN/TURN, UDP, IP | null | 0 | 1491163875 | False | 0 | dfqnhg3 | t3_62z7p7 | null | null | t1_dfqgsa1 | null | 1493735216 | 3 | t5_2fwo | null | null | null |
null | bvierra | null | yep, you can click settings and turn it off for your ip (its on the top right of the returned page that is served for an nxdomain) | null | 0 | 1491163985 | False | 0 | dfqnkf7 | t3_62vx64 | null | null | t1_dfqjbkq | null | 1493735256 | 1 | t5_2fwo | null | null | null |
null | kylotan | null | Not entirely true; it's common to extrapolate if necessary, for example if one client is late responding. As long as you smooth the subsequent correction afterwards, it's fine for many game types. (You'll even see reference to this in the Source Multiplayer Networking page you linked to below.) | null | 0 | 1491163992 | False | 0 | dfqnkm8 | t3_62yl50 | null | null | t1_dfqgp7j | null | 1493735259 | 5 | t5_2fwo | null | null | null |
null | kylotan | null | You're always behind the server. The only question is how you deal with it. | null | 0 | 1491164112 | False | 0 | dfqnnpe | t3_62yl50 | null | null | t1_dfqkiun | null | 1493735300 | 3 | t5_2fwo | null | null | null |
null | rverghes | null | The norm is to change jobs every 2 to 4 years or so. Therefore you have to live somewhere where there are many companies and many potential jobs. Thus, the most expensive cities. | null | 0 | 1491164128 | False | 0 | dfqno3n | t3_62zrgk | null | null | t3_62zrgk | null | 1493735305 | 19 | t5_2fwo | null | null | null |
null | redditpirateroberts | null | I hope it ends up helping! The array idea sounds clever. That test sounds intense haha are you n the military? | null | 0 | 1491164245 | False | 0 | dfqnr41 | t3_62iuku | null | null | t1_dfq361f | null | 1493735346 | 1 | t5_2fwo | null | null | null |
null | sacado | null | wikibooks features a rather good tutorial as far as I remember. | null | 0 | 1491164442 | False | 0 | dfqnwg6 | t3_62wye0 | null | null | t1_dfqevnr | null | 1493735417 | 1 | t5_2fwo | null | null | null |
null | jl2352 | null | I don't have issues working in JS, and neither do plenty of others.
Maybe whine less and get on with it. | null | 0 | 1491164740 | False | 0 | dfqo4nz | t3_62c0k0 | null | null | t1_dfq4fk3 | null | 1493735529 | 1 | t5_2fwo | null | null | null |
null | mmstick | null | Collection types like Vectors, HashMaps, and LinkedLists are examples of low level data structures. A high level data structure is everything you build with these primitives.
You might see raw pointers in low level data structures if you scour through the standard library, purely for optimization purposes, but you won't find them in regular code, as raw pointers are entirely unsafe to work with at scale, and provide no benefit here.
C pointers are raw pointers. Doesn't matter if it's a pointer to a primitive data type or a structure. *const T and *mut T are what you get from C libraries. | null | 0 | 1491164798 | False | 0 | dfqo66b | t3_62wye0 | null | null | t1_dfqnh16 | null | 1493735549 | 2 | t5_2fwo | null | null | null |
null | Codebender | null | The two of you are just talking about different things. You're talking about how the language implements the details, but the other person is talking about how the programmer uses the language.
A monad allows you to write Haskell code that looks imperative, and Linq allows you to write C# code that looks functional. And nothing about those styles forces you to use or not use mutable state. They're orthogonal concepts.
| null | 0 | 1491164950 | False | 0 | dfqoaap | t3_62yl50 | null | null | t1_dfqndtv | null | 1493735604 | 25 | t5_2fwo | null | null | null |
null | go2hello | null | I think handwaving it off with "no true rustacean" and pretending it doesn't happen isn't helpful. | null | 0 | 1491165012 | False | 0 | dfqoc0s | t3_62wye0 | null | null | t1_dfqhoyj | null | 1493735626 | 3 | t5_2fwo | null | null | null |
null | Rusky | null | It can easily be part of a vulnerability, given that a) the size is somehow controllable by an adversary, and b) the offset into the allocation is also controllable. This is pretty common for e.g. image and video handling.
Now, make the allocation it big enough that it fails. (Even on Linux with overcommit on, this can happen if it doesn't fit somewhere in your address space.) Now you presumably have a null pointer dereference immediately following, which means you can read or write anywhere in memory. | null | 0 | 1491165112 | False | 0 | dfqoepi | t3_62wye0 | null | null | t1_dfqij24 | null | 1493735662 | 5 | t5_2fwo | null | null | null |
null | loknarash | null | As a beginner, the complexity of this just makes my eyes roll back into my skull in terror. The nightmarish logistics required to do an MMO...well, the guys that do network code are amazingly intelligent, of that there's no doubt. | null | 0 | 1491165112 | False | 0 | dfqoepz | t3_62yl50 | null | null | t3_62yl50 | null | 1493735662 | 4 | t5_2fwo | null | null | null |
null | heartles | null | /r/interject | null | 0 | 1491165119 | False | 0 | dfqoewp | t3_62tki4 | null | null | t1_dfpd5az | null | 1493735665 | 1 | t5_2fwo | null | null | null |
null | saevarb | null | > I'm unsure if you're explaining it poorly, trying to bend words to fit your narrative, or you don't use Haskell,
I do use Haskell. Haskell has been my preferred general purpose programming language for close to 10 years.
> but the imperative computation defined by an IO type doesn't occur while you're calling bind on it. Binding merely adds actions onto the monad (more accurately returns a new monad with the new action added), like pushing successive statements on a stack. These statements aren't executed until you return an IO monad from your main function.
Obviously. What is that even supposed to mean? Nothing happens when you "call `whatever` on it". Everything happens when it runs. The fact that Haskell uses a non-strict evaluation model has nothing to do with this discussion. And why are you discussing IO? We are talking about monad**s**. Not **a** monad, which is what IO is.
> The imperative program you've thus built in your IO monad is then executed after your main function has finished executing. The functional and imperative aspects of Haskell should be considered two completely distinct parts of the runtime.
Still talking about IO. Still not relevant. Still missing the point.
> Maybe doesn't work like IO at all. It's utilized entirely within the functional Haskell code as-is, not interpreted by a routine that reads off main or anything like that.
The fact that `IO` has to be treated specially due to its very nature is *still* irrelevant. It *does* work like `Maybe`, in the sense that they are both monads.
> And calling Maybe "imperative" is extremely sketchy and I have no idea what are you hanging onto for this conclusion. Most people won't agree with you.
Do you use Haskell? Because most Haskellers who actually know Haskell will tell you that you can do imperative programming by using monads.
It seems to me that you do not understand what imperative means. When I say that a programming language is "imperative", I'm not saying anything about its internal execution model or its semantics, *apart* from the fact that it is imperative means that it lets you execute statements(FSVO) *sequentially*. That's what imperative means.
Let me demonstrate it to you, in Haskell.
-- The "statements" of this program are not executed sequentially.
-- This is because they aren't statements. 'thing' is pure and has
-- some type like (Num a) => a. 'boo' is never evaluated it because it isn't used.
thing =
let baz = foo + bar
boo = 3
in baz
where
foo = 3
bar = 4
imperativeThing :: Maybe Int
imperativeThing = do
value1 <- someMaybeComputation
value2 <- someOtherMaybeComputation
return $ value1 + value2
Basically, in the first example, the evaluation order is really unspecified as it depends on whenever the constituents need to force their arguments. This is not the case in the second example.
[Here's](http://stackoverflow.com/questions/6622524/why-is-haskell-sometimes-referred-to-as-best-imperative-language) [some](https://gist.github.com/gatlin/9696088) [proof](http://code.haskell.org/~slyfox/2014-04-27-haskell-intro.pdf) that "most people" wouldn't disagree. Note how there is only a `Monad m` constraint in the very first example in the first link. It doesn't know about IO.
| null | 0 | 1491165517 | False | 0 | dfqop1t | t3_62yl50 | null | null | t1_dfqndtv | null | 1493735801 | 8 | t5_2fwo | null | null | null |
null | jinwoo68 | null | Show me the code that demonstrates why your language is better than others. Otherwise, nope I won't read tons of documents without knowing what I can benefit from it.
| null | 0 | 1491165535 | False | 0 | dfqopij | t3_631p99 | null | null | t3_631p99 | null | 1493735807 | 27 | t5_2fwo | null | null | null |
null | DysFunctionalProgram | null | How many 3+ line long commands are you writting that are really one offs? And if they even are truley one offs and they are that long then they should probably be documented. | null | 0 | 1491166023 | False | 0 | dfqp1eg | t3_62u62i | null | null | t1_dfqfp6x | null | 1493735966 | 1 | t5_2fwo | null | null | null |
null | lared930 | null | > My problem with these questions is even if the knowledge was needed on the job, it's easy to look up. Even if there isn't an immediate example in your language (which there probably is), then you just translate it.
Not necessarily, if you never encountered this structure you might not know it exists and settle for a shittier alternative instead. | null | 0 | 1491166040 | False | 0 | dfqp1w4 | t3_62xwba | null | null | t1_dfpyq8y | null | 1493735973 | 3 | t5_2fwo | null | null | null |
null | Grue | null | You need to know the algorithm exists before you can even Google it. And if you can remember the algorithm's name and what it does, why not remember how it works while you're at it? Have some pride in your job. | null | 0 | 1491166114 | False | 0 | dfqp3jv | t3_62xwba | null | null | t1_dfq367a | null | 1493735997 | 10 | t5_2fwo | null | null | null |
null | fxfighter | null | I generally don't mind much either way if it's easy to read.
Also keep in mind the last 2.3k~ lines are all test code. | null | 0 | 1491166315 | False | 0 | dfqp8tl | t3_62z7p7 | null | null | t1_dfqfbqq | null | 1493736067 | 8 | t5_2fwo | null | null | null |
null | combinatorylogic | null | Sounds interesting. Where can I read about this language? | null | 0 | 1491166329 | False | 0 | dfqp951 | t3_631p99 | null | null | t3_631p99 | null | 1493736071 | 3 | t5_2fwo | null | null | null |
null | combinatorylogic | null | Can you enjoy programming at all if metaprogramming is not available?
EDIT: this sub is full of ignorant retarded code monkeys who should have never been allowed to program. | null | 0 | 1491166370 | 1491183704 | 0 | dfqpa5w | t3_631p99 | null | null | t1_dfqn95w | null | 1493736086 | -30 | t5_2fwo | null | null | null |
null | lared930 | null | To be honest writing BFS or DFS is not exactly something you have to study if you know the idea behind it. Just like you don't usually have to remind yourself about binary search. | null | 0 | 1491166478 | False | 0 | dfqpct1 | t3_62xwba | null | null | t1_dfqh9o5 | null | 1493736128 | 7 | t5_2fwo | null | null | null |
null | [deleted] | null | [deleted] | null | 0 | 1491166515 | 1492910890 | 0 | dfqpdq7 | t3_62vx64 | null | null | t1_dfqghfj | null | 1493736144 | 1 | t5_2fwo | null | null | null |
null | nilamo | null | How to hack ethically: if you wouldn't be stoked to have it happen to you, then don't do it yourself. ...end of book? | null | 0 | 1491166564 | False | 0 | dfqpetv | t3_62z2fv | null | null | t3_62z2fv | null | 1493736158 | 1 | t5_2fwo | null | null | null |
null | RoGryza | null | Not if the cross-platform tool is more complex than all these different build scripts combined. Depends on how many platforms you're supporting I guess. | null | 0 | 1491166774 | False | 0 | dfqpk71 | t3_62zk1i | null | null | t1_dfql9xq | null | 1493736280 | 2 | t5_2fwo | null | null | null |
null | tkannelid | null | You will get rather biased random numbers from this. I'm guessing you added the function to randomize the list of characters because you noticed strings of consecutive characters?
Beyond that, your code is a little hairy. You used a loop and subtraction when modular arithmetic will do. You split things across a bunch of files, including event listeners inline in the HTML, so it's hard to figure out what the code is doing. (Relative to its length, anyway. It should have been one minute and was more like five.) | null | 0 | 1491166800 | False | 0 | dfqpkpo | t3_62zhhq | null | null | t1_dfqg62i | null | 1493736290 | 3 | t5_2fwo | null | null | null |
null | [deleted] | null | Don't you ever get tired of posting this bullshit? | null | 0 | 1491166943 | False | 0 | dfqpoii | t3_631p99 | null | null | t1_dfqpa5w | null | 1493736367 | 6 | t5_2fwo | null | null | null |
null | editor_of_the_beast | null | Yea this particular program was written wayyy before C++11 was released, and smart pointers in particular would have helped a lot of issues. C++ has come a long way, I still love it. But having a compiler error for returning a pointer to a variable on the stack in a function still seems like the better thing to do. | null | 0 | 1491166974 | False | 0 | dfqppdj | t3_62wye0 | null | null | t1_dfqmq9e | null | 1493736380 | 1 | t5_2fwo | null | null | null |
null | irrationalskeptic | null | Or you could be like Duck Game and just give up on synchro | null | 0 | 1491167013 | False | 0 | dfqpqg6 | t3_62yl50 | null | null | t3_62yl50 | null | 1493736397 | 1 | t5_2fwo | null | null | null |
null | [deleted] | null | [deleted] | null | 0 | 1491167053 | False | 0 | dfqprh0 | t3_631p99 | null | null | t1_dfqpoii | null | 1493736416 | -13 | t5_2fwo | null | null | null |
null | inmatarian | null | Because technology companies are __highly__ selective in their hiring process, and for a city to be able to support a workforce of software developers, there needs to be dozens if not hundreds of places for those developers to interview with. If they go through all five of your companies, and wash out at each because they failed to write a shunting yard implementation from memory onto a tiny whiteboard without error, then they can't live in your city. | null | 0 | 1491167295 | False | 0 | dfqpxb7 | t3_62zrgk | null | null | t3_62zrgk | null | 1493736514 | 6 | t5_2fwo | null | null | null |
null | LtAramaki | null | > The fact that Haskell uses a non-strict evaluation model has nothing to do with this discussion.
I wasn't referring to non-strict evaluation whatsoever. So you're the who just introduced it to this conversation.
And that's not a great idea, because non-strict evaluation goes against the expectations for an imperative language.
> Do you use Haskell? Because most Haskellers who actually know Haskell will tell you that you can do imperative programming by using monads.
Yes and when they're saying that, they're referring to specific monads like IO, which you say "has nothing to do with it".
People are saying you **can** do imperative programming through specific monads, not that you **are** doing imperative programming merely by using any type of monads. Do you understand the subtle yet crucial difference?
You seem to think that monads in general represent imperative code. Which is complete nonsense.
> Here's some proof that "most people" wouldn't disagree.
You're presenting "proof" about `Maybe` being considered "imperative"... which "proof" manages not to mention `Maybe` even once.
What are you relying on here? The obviously tongue-in-cheek title? Nothing in that PDF actually supports the premise that Haskell is an "imperative language", it's all about its functional features and type system. | null | 0 | 1491167411 | 1491167898 | 0 | dfqq02z | t3_62yl50 | null | null | t1_dfqop1t | null | 1493736560 | -6 | t5_2fwo | null | null | null |
null | whisnantryd | null | They've actually simplified in an interesting way. If you went the traditional route and stored mappings in a database you would still need to hit dns to resolve the address. They're just eliminating the extra step. | null | 0 | 1491167415 | False | 0 | dfqq06t | t3_62vx64 | null | null | t1_dfprq5b | null | 1493736560 | 1 | t5_2fwo | null | null | null |
null | danosot | null | Hi, That sounds cool, we was working on it for a long time and we just released a beta version, it would be nice to see your work. | null | 0 | 1491167479 | False | 0 | dfqq1tb | t3_62b50p | null | null | t1_dflc6v9 | null | 1493736591 | 1 | t5_2fwo | null | null | null |
null | Eirenarch | null | > That’s why aspiring writers move to New York City, and even directors and actors who found international success are still drawn to L.A. like moths to a klieg light. Now it is true of tech too.
And then Skype comes from Estonia and the Witcher is made in Poland, John Carmack lives in Texas and Microsoft made HoloLens in Seattle. | null | 0 | 1491167498 | False | 0 | dfqq26t | t3_62zrgk | null | null | t3_62zrgk | null | 1493736599 | 10 | t5_2fwo | null | null | null |
null | shevegen | null | Quite frankly, with that money they could just clone nobu so that there is a second one and then have him hack away on mruby and improve it.
Considering that ruby originated from Japan (well, from matz, but he is from Japan) and that Japan has also sponsored several ruby-related projects (including, well, mruby), it would seem like a logical choice to me if Japan (well, some ministers... don't they have some for computer technology or something like that?) would further support mruby.
> As a general remark it is as always: C sucks as a language to write stable code in
> a simple manner.
I can't resist ... given that first april wasn't long ago...
You could have used rust. :)))))))
> I have high hopes whenever I have the time to work with Rust but in the short-
> or even mid-term it is unrealistic to expect that the Rust community will be big
> enough so that we would find contributors for a niche project like mruby.
Whoa ... slow down Django ...
I use ruby myself since a very long time. No problem here.
But ... IF you actually discover a lot of bugs - and the blog entry claims that -
then, well ... I'd assume that these bugs were primarily discovered BECAUSE
of that bug bounty "look for bugs" project. Why were these bugs not discovered
earlier, then?
And here is where the comment about rust and it being a niche project kicks
in too. Because apparently one bottle-neck for mruby would then be contributors
who understand C very, very well.
In other words, there would already be a shortage of C hackers. So for rust,
this would be even more problematic simply because fewer people know
rust compared to C.
So what is then the real gain by using rust exactly? To have ... even fewer
maintainers and programmers? For ... "rust is safe" benefits? Do these
benefits even outweigh any other disadvantage?
I do not know shopify, I also do not know any of their political activities
and what is most important, I also do not care. I did not even google it
and this will happily remain that way for me. Because I do not see why I
should be interested. I mention this however had in particular because
apparently SOME (random) company out there considers it worthwhile
for them to actually invest money into STAYING WITH RUBY.
And this, in many ways, actually means that matz succeeded. :)
(Since you can make the case for alternative languages to be used,
like lua! Or ... well. Perl. Perl 8 or something like that. PHP will be at
version 20 then - will probably skip 2 released versions in a bit...)
| null | 1 | 1491167571 | False | 0 | dfqq46g | t3_630ysh | null | null | t3_630ysh | null | 1493736634 | 2 | t5_2fwo | null | null | null |
null | shevegen | null | Google actually deteriorated youtube on its own too.
I am getting increasingly annoyed at "content" presented to me that is of no interest. One day I'm gonna censor the side panel to the right side since it is just spam really (IF the videos there are largely useless; if they are not useless to you then this point obviously will not apply). | null | 0 | 1491167635 | False | 0 | dfqq5uz | t3_62zdsh | null | null | t1_dfq8n3o | null | 1493736666 | 6 | t5_2fwo | null | null | null |
null | danosot | null | Hi, you are totally right it was very expensive, and we just fixed the price, it is now $2 per 1.000 pages, let me know that sounds better. Remember we are also trying to give our users tools to easy implement the service and the design creation without cost, there is also a free plan with 50 pages per month. | null | 0 | 1491167675 | False | 0 | dfqq6x9 | t3_62b50p | null | null | t1_dfll0t0 | null | 1493736686 | 1 | t5_2fwo | null | null | null |
null | shevegen | null | Agreed.
Twitch is superior in regards to live-casting. | null | 0 | 1491167684 | False | 0 | dfqq76k | t3_62zdsh | null | null | t1_dfqchyy | null | 1493736693 | 1 | t5_2fwo | null | null | null |
null | vytah | null | The hardest part of learning Kotlin, if you already know Java and few other languages, is syntax – almost everything else you already know, you just get it in a more polished form. And as for syntax, you'll get used to it after your IDE yells at you few times in red. | null | 0 | 1491167793 | False | 0 | dfqqa2j | t3_62utum | null | null | t1_dfq1adq | null | 1493736742 | 4 | t5_2fwo | null | null | null |
null | doom_Oo7 | null | Is a single of the algorithms mentioned here not implemented in boost ? | null | 0 | 1491167839 | False | 0 | dfqqbav | t3_62xwba | null | null | t1_dfqe5ea | null | 1493736762 | 2 | t5_2fwo | null | null | null |
null | dgmdavid | null | Hey Bill. I'll be testing it sometime soon, but is it absolutely necessary to have MSVC 2015? Or can I tinker a little to get it going on MSVC 2013? | null | 0 | 1491167863 | False | 0 | dfqqbx7 | t3_631p99 | null | null | t3_631p99 | null | 1493736778 | 2 | t5_2fwo | null | null | null |
null | vytah | null | Which JS-based editor's changelog is it? | null | 0 | 1491167958 | False | 0 | dfqqehh | t3_62n5mx | null | null | t1_dfoiwjo | null | 1493736819 | 2 | t5_2fwo | null | null | null |
null | valenterry | null | > Every functional language has some way of storing a mutable state. It might be hidden/abstracted away or it might be solved by just accessing some other data structure written in another language.
That's like saying "every language has goto. It might be hidden/abstracted away (...)". It's true but not that interesting. | null | 0 | 1491168000 | False | 0 | dfqqflp | t3_62yl50 | null | null | t1_dfqjd7g | null | 1493736841 | 11 | t5_2fwo | null | null | null |
null | shevegen | null | I think a lot has to do with opportunities.
I live in a city that has close to 2 million people which isn't too bad.
Compare this to London or Hong Kong - and I know that the latter two cities have a higher appeal to me (but for several reasons, moving away to either one isn't as simple ...) | null | 0 | 1491168037 | False | 0 | dfqqgl9 | t3_62zrgk | null | null | t3_62zrgk | null | 1493736859 | 1 | t5_2fwo | null | null | null |
null | shevegen | null | You can earn a lot in the center - but live on the outskirts.
London has this to a high extent. | null | 0 | 1491168065 | False | 0 | dfqqhb8 | t3_62zrgk | null | null | t1_dfqn2nk | null | 1493736872 | 7 | t5_2fwo | null | null | null |
null | textfile | null | I've been watching some Rich Hickey videos recently, can you recommend any links related to Clojure/networking/state deltas for further reading? | null | 0 | 1491168121 | False | 0 | dfqqiss | t3_62yl50 | null | null | t1_dfq7kta | null | 1493736898 | 3 | t5_2fwo | null | null | null |
null | simion314 | null | Creators will have to find different ways to make money or they will have to create family friendly content only. | null | 0 | 1491168142 | False | 0 | dfqqjee | t3_62zdsh | null | null | t1_dfqabga | null | 1493736908 | 1 | t5_2fwo | null | null | null |
null | fly-hard | null | For older MMOs at least, you may be surprised to learn the network model is simpler than with FPSes. For example, in Dark Age of Camelot, an MMO from 2001, the client sends its current position four times a second to the server, and the server merely forwards the client's packets out to all other clients that are in range. That's how they support thousands of players on a server group; the server's not actually doing much work to process client movement.
| null | 0 | 1491168154 | False | 0 | dfqqjp7 | t3_62yl50 | null | null | t1_dfqoepz | null | 1493736914 | 8 | t5_2fwo | null | null | null |
null | thechao | null | There are two things you're trying to do: (1) minimize the actual number of system calls; and, (2) minimize the number of distinct allocations you're tracking. The first can be accomplished by using an arena allocator, or something in that family. The latter requires good architectural design. For instance, in a VM, there's probably a large number of "scratch" allocations that occur—small one-off, local, variably sized allocations to do work in. If you can come up with an "upper bound" on those allocations, and their lifespan is restricted to, say, a single function, then you can just reserve a single scratch zone & reuse it. | null | 0 | 1491168261 | False | 0 | dfqqmmz | t3_62wye0 | null | null | t1_dfqhsd6 | null | 1493736973 | 2 | t5_2fwo | null | null | null |
null | mywan | null | Given that the midpoint displacement algorithm depends on a random offset of the center point it seems like you would need to store the generated map data pretty much in its entirety to have a persistent map. Otherwise each time it's generated it would produce a different map. How hard would it be to replace the random() function with a deterministic function that took map coordinates (of whatever form) as inputs to consistently regenerate the exact same map with minimal data storage? Say just a list of constants that dictate what map is to be generated. | null | 0 | 1491168287 | False | 0 | dfqqncn | t3_630cgb | null | null | t3_630cgb | null | 1493736984 | 17 | t5_2fwo | null | null | null |
null | saevarb | null | Look. In the *very first link* I posted, in the *very first example*, there is a demonstration of *imperative code in Haskell*. This code has **no constraint other than the `Monad` constraint**. This means this code works for **all** monads. That is literally the *opposite* of dealing with a specific monad. This code is imperative because the "statements" are evaluated *sequentially*. This is what imperative means.
Here is my original statement:
> You can write imperative code in Haskell. Monads are for sequencing computations.
My point was just that "pure and immutable" and "imperative" are not antonyms and can definitely coexist in a language.
In my previous post, I proved all of the things in that statement, if you only look at the links. I can explain it to you, but I can't understand it for you. If the previous didn't do it for you, then I can't help you, and we have nothing else to discuss and should probably just move on with our lives.
But as a last resort, here's a link directly from Wikibooks on Haskell and how monads are imperative: https://en.wikibooks.org/wiki/Haskell/Understanding_monads#Notions_of_Computation | null | 0 | 1491168350 | False | 0 | dfqqp41 | t3_62yl50 | null | null | t1_dfqq02z | null | 1493737009 | 6 | t5_2fwo | null | null | null |
null | WittyAdrian | null | Fair point | null | 0 | 1491168479 | False | 0 | dfqqsu9 | t3_62yl50 | null | null | t1_dfqnnpe | null | 1493737058 | 1 | t5_2fwo | null | null | null |
null | [deleted] | null | [removed] | null | 0 | 1491168575 | False | 0 | dfqqvny | t3_631p99 | null | null | t1_dfqn7pf | null | 1493737097 | 1 | t5_2fwo | null | null | null |
null | Nastapoka | null | You're way too nice with this asshole | null | 0 | 1491168583 | False | 0 | dfqqvvv | t3_62yl50 | null | null | t1_dfqjya6 | null | 1493737100 | 4 | t5_2fwo | null | null | null |
null | Manishearth | null | I'm not. Many of these programmers are Rustaceans, no doubt. I'm pointing out the fact that the community as a whole frowns on this, and that I haven't seen _known_ names doing this (you need not be a name I personally recognize to be a Rustacean, that would be silly!).
Of course it happens. Just reaffirming that this is not some organized movement by Mozilla or the community. If you see folks doing it, please call them out on it. | null | 0 | 1491168590 | False | 0 | dfqqw3a | t3_62wye0 | null | null | t1_dfqoc0s | null | 1493737103 | 6 | t5_2fwo | null | null | null |
null | username4333 | null | The fact that this was released the day before april fools is confusing
| null | 0 | 1491168849 | False | 0 | dfqr3ic | t3_62m5uf | null | null | t3_62m5uf | null | 1493737203 | 1 | t5_2fwo | null | null | null |
null | xplane80 | null | Have a go with getting it working in MSVC 2013. I just use some of the C99 features. | null | 0 | 1491168913 | False | 0 | dfqr59r | t3_631p99 | null | null | t1_dfqqbx7 | null | 1493737226 | 2 | t5_2fwo | null | null | null |
null | unpopular_opinion | null | Ignorance is enough reason to invest in Ruby. | null | 1 | 1491169072 | False | 0 | dfqr9rd | t3_630ysh | null | null | t1_dfqq46g | null | 1493737288 | 2 | t5_2fwo | null | null | null |
null | gingerbill | null | I have yet to write up a tutorial or xinyminutes-style thing for Odin however, there are numerous videos of the demos:
[Odin Compiler Demos Playlist](https://www.youtube.com/playlist?list=PL93bFkoCMJsmqyk5C7hAAIytEfpMDunQ9) | null | 0 | 1491169084 | False | 0 | dfqra4g | t3_631p99 | null | null | t1_dfqp951 | null | 1493737292 | 1 | t5_2fwo | null | null | null |
null | LtAramaki | null | > This code is imperative because the "statements" are evaluated sequentially. This is what imperative means.
You forgot half the definition of "imperative" I'm afraid:
> A series of sequential steps that change the state of the application.
You can write code that *looks* very "imperative" with the `do` notation, but it doesn't result in any state changes, unless you're using a handful of monads that are designed to expose effects and state to Haskell.
Plus the thing you don't want to talk about, lazy evaluation, means you can't even be sure when and how those "sequential statements" will be executed. Sure, they'll remain in the same partially ordered set of instructions to eventually maybe run, but you don't know what that entire set is, nor when it'll run, nor whether it'll run in full and under what conditions.
Imperative programming isn't simply the assumption that when you write "A; B; C; D" that B will run after A. It's also the assumption that these statements will run when they're called, in full, and they'll carry changes to the application state.
To **truly** do "imperative" programming in Haskell, means to constantly litter your code with strict evaluation annotations and use things like `System.IO.Unsafe` which allow you to directly execute effects. That would be imperative. Not just "looks like imperative when you take your glasses off and squint a little".
So yeah, you can do it, but you'll eventually hate yourself for not just using Java or C++ if you go this way. | null | 0 | 1491169155 | 1491169346 | 0 | dfqrc6d | t3_62yl50 | null | null | t1_dfqqp41 | null | 1493737320 | -5 | t5_2fwo | null | null | null |
null | salgat | null | This is perhaps the strongest argument for living in the city. We make the majority of our salary bumps through changing jobs, which is harder to do unless you live in a very dense area with jobs. | null | 0 | 1491169215 | False | 0 | dfqrdz5 | t3_62zrgk | null | null | t1_dfqno3n | null | 1493737344 | 8 | t5_2fwo | null | null | null |
null | salgat | null | What scares me is that there is a ton of emphasis on these algo questions and almost none on design patterns, which is far more important to get right. I don't give a shit if you can implement 4 different types of sorting or a balanced tree if you are going to throw singletons all over your code and completely forgo interfaces and DI. | null | 0 | 1491169464 | False | 0 | dfqrkz0 | t3_62xwba | null | null | t1_dfpyq8y | null | 1493737438 | 7 | t5_2fwo | null | null | null |
null | salgat | null | It scares me that you would implement this without doing your proper due diligence to look up implementations which are more vetted and safer to use. It takes me all of a few minutes to look up an algo to check if there is a better implementation before I roll my own. | null | 0 | 1491169584 | False | 0 | dfqrohk | t3_62xwba | null | null | t1_dfqf0c7 | null | 1493737485 | 3 | t5_2fwo | null | null | null |
null | murkaje | null | If you give the pseudo-random function the same seed, the resulting map will be the same. Some games that have generated terrains ask for seed input(e.g. minecraft) so you can write it down if the resulting world was to your taste. | null | 0 | 1491169594 | False | 0 | dfqror4 | t3_630cgb | null | null | t1_dfqqncn | null | 1493737488 | 57 | t5_2fwo | null | null | null |
null | metaconcept | null | Because employers are old fashioned. They want to look over their vast cubicle kingdom at all the chair dwellers they own.
| null | 0 | 1491169667 | False | 0 | dfqrqvo | t3_62zrgk | null | null | t3_62zrgk | null | 1493737517 | 23 | t5_2fwo | null | null | null |
null | salgat | null | This is a pretty uncommon circumstance, and is a use case usually filled by map. | null | 0 | 1491169751 | False | 0 | dfqrtbh | t3_62xwba | null | null | t1_dfqbhuo | null | 1493737550 | 0 | t5_2fwo | null | null | null |
null | tinfoilboy | null | Installing a Ubuntu partition recently in my case took far less than an hour, was pleasantly surprised. | null | 0 | 1491169913 | False | 0 | dfqrxxv | t3_62ji76 | null | null | t1_dfnc930 | null | 1493737611 | 1 | t5_2fwo | null | null | null |
null | motdidr | null | I don't think something needs to never allow mutability, and rust having a keyword to turn something mutable (immutable being the default) sounds reasonable to me. | null | 0 | 1491170036 | False | 0 | dfqs1dq | t3_62yl50 | null | null | t1_dfql6pi | null | 1493737657 | 6 | t5_2fwo | null | null | null |
null | combinatorylogic | null | Not sure video is an adequate media for talking about a language (unless it's a purely visual language), it's impossible to quickly skim through. I wanted to see examples of a metaprogramming. Odin code in the repository seems to only contain FFI bindings, so it's not very representative of the language features. Though, the IR code is quite clean so I got the idea. Did I miss any other examples there? | null | 0 | 1491170043 | False | 0 | dfqs1kg | t3_631p99 | null | null | t1_dfqra4g | null | 1493737659 | 11 | t5_2fwo | null | null | null |
null | Derpscientist | null | That's what the tests, feature toggles, and code reviews are for. It would be a pretty big news story if there was an issue with it. There's no library for doing what I'm doing. | null | 0 | 1491170071 | False | 0 | dfqs2d4 | t3_62xwba | null | null | t1_dfqrohk | null | 1493737670 | 2 | t5_2fwo | null | null | null |
null | dangerbird2 | null | There are *tons* of make-like build DSLs written in general-purpose programming languages. Rake for ruby, fake in fsharp, gulp/grunt/buildtooloftheweek in javascript. sbt in scala, etc... These are often used with the language they're written in, but can be used for generic build configurations. | null | 0 | 1491170129 | 1491170415 | 0 | dfqs3zr | t3_62zk1i | null | null | t1_dfq9og4 | null | 1493737692 | 2 | t5_2fwo | null | null | null |
null | gingerbill | null | I was originally creating external metaprogramming tools to "fix" my problems with C/C++ but I got fed up and thought why not create a new language instead. Odin is meant to replace my personal need for C and C++.
I have been heavily researching the available languages that could replace my need for C and C++. D, Rust, Nim, and Go are the best options that I have found however, none of them are what I want.
A main goal with Odin is to keep it simple to read and write whilst being able to solve real world problems. I want it to a modern C built for modern hardware without any of the legacy baggage C carries.
## Quick Overview of Features (in no particular order):
* Full UTF-8 Support
* Custom allocations that are simple to use
* Memory arenas/regions, pools, stacks, etc. which can be easily added
* Context system for allocations and thread data
* Built in types and functions that take advantage over the context system for allocations
* `new(Type)` uses the context's allocator
* Dynamic arrays and Hash Tables
* Vector types to reflect vector instructions
* `[vector 4]f32`
* Function overloading
* Introspection on all types
* High control over memory layout of records
* Decent "modules" and file/library handling
* No _bad_ preprocessor
* Type inference
* `x: int = 1;`
* `x := 1; // x is deduced to be an int`
* `using`
* making everything a namespace and removing the need for constructors and weird inheritance (idea borrowed from Jai)
* Multiple return types
* Clean, consistent, and fast to parse syntax
* No need for function prototypes
* `defer`
* defer a statement until the end of scope (akin to D's `scope(exit)`)
* Nested functions and types
* Tagged unions and untagged unions
* Ranged `for` loops
* Labelled branches
* `break label_name;`
* `break` by default in `match` statements
* Explicit `fallthrough`
* "Raw" strings
* compile time `when` statements
* Bounds checking which is togglable at the statement level
* `#no_bounds_check` `#bounds_check`
* And so much more | null | 0 | 1491170202 | 1491170750 | 0 | dfqs63n | t3_631p99 | null | null | t1_dfqopij | null | 1493737720 | 11 | t5_2fwo | null | null | null |
null | saevarb | null | > A series of sequential steps that change the state of the application.
Okay. What is this 'state'? Has it been globally defined to be some mutable memory somewhere? Because I can just use the State monad and change the state of my application. "The state of the application" is entirely dependent on the application, not the underlying execution model. If the state of my application is a list of numbers inputted by the user, then I can write an imperative program in Haskell using the state monad that will be "changing the state of the application."
> Imperative programming isn't simply the assumption that when you write "A; B; C; D" that B will run after A. It's also the assumption that these statements will run when they're called, in full, and they'll carry changes to the application state.
Okay. So... what about the program
int main(void) {
int i;
i;
i;
i;
i;
i;
}
I don't see any state being changed here, so I guess this isn't imperative?
> Plus the thing you don't want to talk about, lazy evaluation, means you can't even be sure when and how those "sequential statements" will be executed. Sure, they'll remain in the same partially ordered set of instructions to eventually maybe run, but you don't know what that entire set is, nor when it'll run, nor whether it'll run in full and under what conditions.
Now you're just being ridiculous. You can *never* be sure how a program executes, because that means solving the halting problem. Haskell's non-strict execution model isn't just defined randomly. It is specified very clearly and unambiguously, and I can reason about it just like any other reasonable model in any other programming language.
You have done the job of demonstrating that you don't know what you're talking about for me, so I don't really need address the rest. | null | 0 | 1491170312 | False | 0 | dfqs9d9 | t3_62yl50 | null | null | t1_dfqrc6d | null | 1493737763 | 5 | t5_2fwo | null | null | null |
null | suckywebsite | null | They're chasing after expensive ass. | null | 0 | 1491170362 | False | 0 | dfqsarn | t3_62zrgk | null | null | t3_62zrgk | null | 1493737782 | 1 | t5_2fwo | null | null | null |
null | LtAramaki | null | In general I agree, but the whole thread started with how pure functional programming is the best and we don't need anything else to program efficient multiplayer games.
I personally think what Rust does is pretty smart and pragmatic. And it in many ways defies categorization. | null | 0 | 1491170367 | False | 0 | dfqsawx | t3_62yl50 | null | null | t1_dfqs1dq | null | 1493737784 | 2 | t5_2fwo | null | null | null |
Subsets and Splits
Filtered Reddit Uplifting News
The query retrieves specific news articles by their link IDs, providing a basic overview of those particular entries without deeper analysis or insights.
Recent Programming Comments
Returns a limited set of programming records from 2020 to 2023, providing basic filtering with minimal analytical value.