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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
True
|
AeroNotix
| null |
I was wondering what he meant with that Python remark. I would have thought that knowing Python well filters you OUT of the potentials pool?
| null |
0
|
1317220533
|
False
|
0
|
c2n82xv
|
t3_ktxzn
| null |
t1_c2n82xv
|
t1_c2n7b54
| null |
1427658073
|
1
|
t5_2fwo
| null | null | null |
True
|
jerf
| null |
Such programs exist; I've seen the results. But there are many strong programs that force many programming languages on people.
| null |
0
|
1317220536
|
False
|
0
|
c2n82ye
|
t3_kteac
| null |
t1_c2n82ye
|
t1_c2n7euv
| null |
1427658073
|
3
|
t5_2fwo
| null | null | null |
True
|
dead_ed
| null |
Your story sounds like my one experience with the process: 1) Oh, let's do this as we need help with our planning. Don't look so sad. 2) Endless buzzword meetings in lieu of actual work! 3) Wait, are we still doing the buzzwords thing because that's just adding a thick layer of bullshit. 4) Okay, let's just go back to half-assing our way through the day 5) We're done!
| null |
0
|
1317220582
|
False
|
0
|
c2n835r
|
t3_ktxk5
| null |
t1_c2n835r
|
t1_c2n7kes
| null |
1427658076
|
5
|
t5_2fwo
| null | null | null |
True
|
nadanadanada
| null |
ithika was talking about trying to untangle nightmarish code, I think refactor is a good place to start, What would you do?
In crude terms refactoring means that if you have some really ugly code that you want to change, you refactor without changing the behaviour, the best way to do that AFAIK is with tests.
A more formal description: Code refactoring is "disciplined technique for restructuring an existing body of code, altering its internal structure without changing its external behavior
| null |
0
|
1317220616
|
True
|
0
|
c2n83bq
|
t3_ktg8c
| null |
t1_c2n83bq
|
t1_c2n7p4w
| null |
1427658078
|
2
|
t5_2fwo
| null | null | null |
True
|
codesilverback
| null |
Either your management trusts the team or you can't use scrum.
| null |
0
|
1317220671
|
False
|
0
|
c2n83kn
|
t3_ktxk5
| null |
t1_c2n83kn
|
t1_c2n7kes
| null |
1427658081
|
12
|
t5_2fwo
| null | null | null |
True
|
dumael
| null |
Ah, a smart text editor. Yeah, that works as long as the editor + compiler agree on grammar though most probably will.
It's more the general case that people are worried about for the dangling else problem where the standards/developers can't rely on sufficiently smart editors that the article is worried.
| null |
0
|
1317220758
|
False
|
0
|
c2n83zi
|
t3_kooiy
| null |
t1_c2n83zi
|
t1_c2n7xke
| null |
1427658087
|
1
|
t5_2fwo
| null | null | null |
True
|
deltwalrus
| null |
If anyone could invent a system or program that instantly plays some other, any other music over R.E.M., I would pay handsomely for it.
| null |
0
|
1317220779
|
False
|
0
|
c2n843n
|
t3_ku203
| null |
t1_c2n843n
|
t3_ku203
| null |
1427658088
|
7
|
t5_2fwo
| null | null | null |
True
|
tominated
| null |
That's a lot harder to read than the ruby version imo (although I don't really know haskell at all)
| null |
0
|
1317220805
|
False
|
0
|
c2n847d
|
t3_ku2z1
| null |
t1_c2n847d
|
t1_c2n82kf
| null |
1427658091
|
1
|
t5_2fwo
| null | null | null |
True
|
cwstjnobbs
| null |
Yes, but developers shouldn't be expected to cater for people who are stuck in the 90's.
| null |
0
|
1317220813
|
False
|
0
|
c2n8492
|
t3_ktenx
| null |
t1_c2n8492
|
t1_c2n82jj
| null |
1427658091
|
-1
|
t5_2fwo
| null | null | null |
True
|
serudla
| null |
JSF2 does seem like a titanic improvement over previous versions. I have tried using it with Seam. That Seam makes using JSF tolerable is pretty amazing. But love it? No way (not yet, at least).
| null |
0
|
1317220894
|
True
|
0
|
c2n84mf
|
t3_kt682
| null |
t1_c2n84mf
|
t1_c2n81vj
| null |
1427658095
|
0
|
t5_2fwo
| null | null | null |
True
|
Amablue
| null |
> Maintaining two muscle memories (does not work), or
At work I use gVim for editing all the data files in our application (where I generally spend most of my time) and Visual Studio to do all the work in C, I've never had a real problem with muscle memory betraying me. There are the occasional cases where I'll go to his :w when I really want ctrl+s, or something like that, but they're uncommon and don't really cause any problem.
> The people who designed the modern text editor relied on studies which said this was not the case. Mouse-based editing is much faster than it feels, shortcut-based editing is quite a bit slower than it feels.
I'm very skeptical of this claim. If you're talking about people who are not experts on either system, I can understand the mouse being faster, but I have a hard time believing that a sufficiently experienced Vim user would be faster with mouse usage. There are so many very fast ways to move in Vim.
| null |
0
|
1317220931
|
False
|
0
|
c2n84tf
|
t3_ktenx
| null |
t1_c2n84tf
|
t1_c2n70sa
| null |
1427658098
|
2
|
t5_2fwo
| null | null | null |
True
|
iongion
| null |
- Digging in his own site/links, here you can find the software:
http://lucid-code.com/Halographs/
- Don't know where you can find the hardware.
Lucid dreams are something everyone can experience and train to without any device. Best way is to keep a record of your dreams in written form.
Just do this, during a 2 weeks period, write down every detail you can remember from a dream, exactly after waking up from it (not necessary in the morning).
Together with this, do reality checks during daytime, when you are awake(i don't know why, if you repeat it, somehow you will do it in the dreams also).
When you will realize you are in a dream, you will get scared or too joyful and you will awake quite fast(at least this happened/happens for me).
To get back into control and not let your dream fade away, look at your hands(while in the dream), follow every detail of your fingers, turn the hands upside/down, etc ... then move your sight on other things in the dream.
Do not stare at things in the dream that are not your own(like your hands), at least until that first time scare/joy goes away.
When you feel you are loosing control, look at your hands again.
This method does not work every time for not loosing the dream, depends on how relaxed or detached you are given the feeling of great joy that you have when you realized you are dreaming.
You can find more about lucid dream in Carlos Castaneda's books, he explains these techniques as being the ones that ancient people of Sonora used to gain lucid dreaming, some don't believe his teaching, some, as me, tried his techniques(except the ones using drugs) and at least this one with respect to lucid dream helps a lot.
There are some ancient cultures that talk about this experience, i would really like to try them all, but most of them require time and practice.
This device this guy is using is really interesting.
There are other devices that act when they detect REM, by sending tiny pulses to your skin, not too strong to wake you up, but enough to realize, in your dream, that you are dreaming, kind of a shortcut for the hands technique.
Good luck everyone, if any of you have XP with lucid dreams/lucid dreaming it would be nice to get feedback, they are truly an invaluable experience considering we have quite a few REMs per sleep ... not remembering, or experiencing it is like having a missing period of our life passing by.
| null |
0
|
1317220973
|
False
|
0
|
c2n850z
|
t3_ku203
| null |
t1_c2n850z
|
t3_ku203
| null |
1427658101
|
80
|
t5_2fwo
| null | null | null |
True
|
junkit33
| null |
The biggest benefit is you will ALWAYS have vi available on any unix machine. While it's becoming increasingly less common, there are still plenty of machines out there with old/stock installs that aren't connected to the Internet. You never know when you may end up on one. And then you look like an idiot if you don't even know how to use the basics of vi. (Seriously - you can learn everything you absolutely need to know in 5 minutes. Even this very basic tutorial is more than you *need*. i, x, escape, and saving will get you through anything.)
Beyond that, it's an extremely fast and efficient editor. Yes, a giant IDE with all the bells and whistles is great when you're working on a huge project, but sometimes you can edit a line or two of code in vim and be done with the file in the same amount of time as it takes just to open Eclipse.
| null |
0
|
1317220999
|
False
|
0
|
c2n855y
|
t3_ktenx
| null |
t1_c2n855y
|
t1_c2n5v70
| null |
1427658103
|
3
|
t5_2fwo
| null | null | null |
True
|
StrawberryFrog
| null |
> Where I work we make an obvious exception for critical bugs, and they can blow out sprints if they're time intensive
Yeah they can.
One of the things to do in scrum is to actually have the retrospectives, and to learn from historical data of how things actually are, as opposed to how you'd like them to be.
For example, you might recognise that you spend 3 person-days per sprint on average fixing critical bugs in the live systems. So, on each sprint you would put in a 3-day task called "live support", with top priority. If you spend less time on live support than that, you get extra time for lower-priority tasks. If you spend more time on it, then you won't meet some sprint goals but you'll know why.
You might also, if you do retrospectives, start to think about the root causes of the live issues - e.g. are there problem areas? Do they have good test coverage? How good is the code quality? How much refactoring can you do and how does that affect your velocity and error rate? How well does the implementation match with how people are actually using the software?
I don't know if you do retrospectives, but they are part of the standard scum method, and the scrum motto is "inspect and adapt", which is IMHO more important than some of the practices - but if you don't do retrospectives, how do you inspect and adapt?
If live issues totally destroy your ability to get sprints done, then you can't do Scrum and may as well look into Kanban or the like instead.
| null |
0
|
1317221025
|
True
|
0
|
c2n85au
|
t3_ktxk5
| null |
t1_c2n85au
|
t1_c2n73i5
| null |
1427658105
|
9
|
t5_2fwo
| null | null | null |
True
|
elperroborrachotoo
| null |
> crystal clear
never said that. As I said in another reply, once you know there's a difference between messages you can send, and messages you respond to, the documentation is good enough.
BTW. There's nothing stopping you from adding that fact to the community content of that page.
"does not write for MSDN" as in "[MSDN Library](http://msdn.microsoft.com/en-us/library/default.aspx)", colloquially shortened to MSDN because it's the seed and core of MSDN.
| null |
0
|
1317221072
|
False
|
0
|
c2n85if
|
t3_ktv1z
| null |
t1_c2n85if
|
t1_c2n81jx
| null |
1427658107
|
5
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317221199
|
False
|
0
|
c2n864k
|
t3_ktxk5
| null |
t1_c2n864k
|
t1_c2n796q
| null |
1428192712
|
1
|
t5_2fwo
| null | null | null |
True
|
Laziness
| null |
> Wahhabi sect of Linux C++ programmers
I'm going to write that one down and use it later if you don't mind.
| null |
0
|
1317221219
|
False
|
0
|
c2n868c
|
t3_ktv1z
| null |
t1_c2n868c
|
t1_c2n81ju
| null |
1427658119
|
5
|
t5_2fwo
| null | null | null |
True
|
exhuma
| null |
Yeah.... curious as well as to how this is made. Also:
How do you read those graphs?
| null |
0
|
1317221255
|
False
|
0
|
c2n86ep
|
t3_ku203
| null |
t1_c2n86ep
|
t1_c2n7tk7
| null |
1427658130
|
7
|
t5_2fwo
| null | null | null |
True
|
nemtrif
| null |
That's what you say. And [there is this guy who says](http://bartoszmilewski.wordpress.com/2011/01/09/monads-for-the-curious-programmer-part-1/):
> A monad is an endofunctor together with two special families of morphisms, both going vertically, one up and one down. The one going up is called unit and the one going down is called join.
| null |
0
|
1317221355
|
False
|
0
|
c2n86v9
|
t3_ktei7
| null |
t1_c2n86v9
|
t1_c2n2o5k
| null |
1427658127
|
1
|
t5_2fwo
| null | null | null |
True
|
ecafyelims
| null |
http://www.dreamviews.com/members/iamcoder/
http://www.dreamviews.com/f44/presenting-halographs-115730/
http://www.lucid-code.com/Halographs/
http://who.godaddy.com/whois.aspx?domain=lucid-code.com&prog_id=GoDaddy
I see that you own lucid-code.com. When will you be offering the halographs for sale?
| null |
0
|
1317221379
|
False
|
0
|
c2n86yt
|
t3_ku203
| null |
t1_c2n86yt
|
t3_ku203
| null |
1427658128
|
21
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
> The Windows API does not try to prevent you from doing the wrong thing.
What? There are lots of API functions that do a great deal to prevent you from doing the wrong thing. I'm not saying that WM_DESTROY is particularly bad, other than it's documentation. They say that it sent when a window is being destroyed but it would be helpful for them to either say don't send it or what the consequences are of sending it.
| null |
0
|
1317221393
|
False
|
0
|
c2n872c
|
t3_ktv1z
| null |
t1_c2n872c
|
t1_c2n7wlx
| null |
1427658129
|
1
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317221524
|
False
|
0
|
c2n87pw
|
t3_ktv1z
| null |
t1_c2n87pw
|
t1_c2n7njb
| null |
1427658136
|
1
|
t5_2fwo
| null | null | null |
True
|
gospelwut
| null |
I'm just an idiot C# programmer, but I suspected the solution was to just invoke/tell the window to close itself. I'm a bit confused how they over-engineered this solution.
Though, sometimes dealing with WinForms on different threads can feel like "simply dropping The Ring into that lava pit over there."
| null |
0
|
1317221569
|
False
|
0
|
c2n87yi
|
t3_ktv1z
| null |
t1_c2n87yi
|
t3_ktv1z
| null |
1427658139
|
-2
|
t5_2fwo
| null | null | null |
True
|
dyydvujbxs
| null |
"Em" is a 1dimensional unit of width that is derived from font height.
| null |
0
|
1317221614
|
False
|
0
|
c2n886d
|
t3_ktx2g
| null |
t1_c2n886d
|
t1_c2n79sy
| null |
1427658142
|
3
|
t5_2fwo
| null | null | null |
True
|
metadave
| null |
I loved slide 40 ("The basic decision criterion").
Props to Bryan for using both Haskell AND C# on a project.
| null |
0
|
1317221617
|
False
|
0
|
c2n886v
|
t3_ktxzn
| null |
t1_c2n886v
|
t3_ktxzn
| null |
1427658142
|
1
|
t5_2fwo
| null | null | null |
True
|
BrainInAJar
| null |
:s/foo/bar/ alone makes it worth it. Bookmarks are another.
| null |
0
|
1317221638
|
False
|
0
|
c2n88ag
|
t3_ktenx
| null |
t1_c2n88ag
|
t1_c2n4fw1
| null |
1427658143
|
1
|
t5_2fwo
| null | null | null |
True
|
gospelwut
| null |
While this is true, doesn't Microsoft have the onus of immense legacy support?
| null |
0
|
1317221647
|
False
|
0
|
c2n88c8
|
t3_ktv1z
| null |
t1_c2n88c8
|
t1_c2n7otu
| null |
1427658144
|
20
|
t5_2fwo
| null | null | null |
True
|
pnpbios
| null |
go for it.
| null |
0
|
1317221648
|
False
|
0
|
c2n88cg
|
t3_ktv1z
| null |
t1_c2n88cg
|
t1_c2n868c
| null |
1427658144
|
4
|
t5_2fwo
| null | null | null |
True
|
BrainInAJar
| null |
Maybe you like to edit code on nonlocal machines. Like your hefty server in some datacentre across the country
| null |
0
|
1317221731
|
False
|
0
|
c2n88qh
|
t3_ktenx
| null |
t1_c2n88qh
|
t1_c2n6zw2
| null |
1427658149
|
1
|
t5_2fwo
| null | null | null |
True
|
Amablue
| null |
(People on netbooks aren't stuck in the 90's, but whatever)
Developers should cater to whoever is going to earn them money.
I might be a little biased because I'm a game programmer. We did some research on the types of monitors and video cards users had and found that the largest share of users were on 1024x768, which had a larger share of users than any other resolution by at least double. I tend to think that our stats are skewed toward higher end machines too, since it was data taken from gamers, not the general population.
Whenever I do any kind of UI work, or anything that would be affected by screen resolution, I always test on 1024x768.
| null |
0
|
1317221855
|
False
|
0
|
c2n89bk
|
t3_ktenx
| null |
t1_c2n89bk
|
t1_c2n8492
| null |
1427658157
|
3
|
t5_2fwo
| null | null | null |
True
|
DrublicPunk
| null |
That's why there's a "basics" section to explain the concepts.
| null |
0
|
1317221898
|
False
|
0
|
c2n89j1
|
t3_ktxk5
| null |
t1_c2n89j1
|
t1_c2n7kzf
| null |
1427658161
|
5
|
t5_2fwo
| null | null | null |
True
|
DrublicPunk
| null |
T?
| null |
0
|
1317221905
|
False
|
0
|
c2n89k2
|
t3_ktxk5
| null |
t1_c2n89k2
|
t1_c2n76qv
| null |
1427658161
|
3
|
t5_2fwo
| null | null | null |
True
|
WormSlayer
| null |
My voodoo card came with a hardware accelerated version of MechWarrior 2 :D
| null |
0
|
1317221965
|
False
|
0
|
c2n89us
|
t3_ktd67
| null |
t1_c2n89us
|
t1_c2n54w4
| null |
1427658165
|
1
|
t5_2fwo
| null | null | null |
True
|
Reaper666
| null |
[PDF:When Will a Genetic Algorithm Outperform Hill Climbing? ](http://web.cecs.pdx.edu/~mm/nips93.pdf)
| null |
0
|
1317221972
|
False
|
0
|
c2n89w9
|
t3_ktg7o
| null |
t1_c2n89w9
|
t1_c2n7y89
| null |
1427658165
|
2
|
t5_2fwo
| null | null | null |
True
|
bratty_fly
| null |
Aah, but you have to assume a prior! And your answer will depend on the prior you choose.
By the way, it's easy to do better than the uniform prior he decides to use, but then the math becomes more complex.
| null |
0
|
1317221981
|
False
|
0
|
c2n89xt
|
t3_ktx2g
| null |
t1_c2n89xt
|
t3_ktx2g
| null |
1427658166
|
6
|
t5_2fwo
| null | null | null |
True
|
boobsbr
| null |
the joy of pure text, no distractions. great for console users.
| null |
0
|
1317222010
|
False
|
0
|
c2n8a2c
|
t3_ktd67
| null |
t1_c2n8a2c
|
t1_c2n4kji
| null |
1427658175
|
2
|
t5_2fwo
| null | null | null |
True
|
Sigma7
| null |
My question about the original code: Why not use WM_QUIT to terminate that thread? It has the same effect - you tell a given message queue to terminate without actually cleaning up the stuff it left behind.
Or even better, use WM_CLOSE, which automatically calls DestroyWindow() on itself, as [documented in the API](http://msdn.microsoft.com/en-us/library/windows/desktop/ms632617(v=vs.85\).aspx).
I also checked out WM_DESTROY. A window that receives the message does nothing with it, and presumes the cleanup is actually handled by DestroyWindow. It's also sent only after it's removed from the screen, and posting the WM_DESTROY message directly doesn't do that.
| null |
0
|
1317222048
|
False
|
0
|
c2n8a8h
|
t3_ktv1z
| null |
t1_c2n8a8h
|
t1_c2n7s6w
| null |
1427658179
|
3
|
t5_2fwo
| null | null | null |
True
|
gospelwut
| null |
But my users complain if I don't have an ajaxspin.gif indicating it is is "doing something". They get scared and send me tickets. </joke sort of>
| null |
0
|
1317222068
|
False
|
0
|
c2n8ac2
|
t3_ktv1z
| null |
t1_c2n8ac2
|
t1_c2n7qbh
| null |
1427658180
|
3
|
t5_2fwo
| null | null | null |
True
|
cwstjnobbs
| null |
People on netbooks understand that their hardware is incapable of displaying things correctly due to its inferior size. I never see netbook users complain about a webpage, only about their netbooks.
Anyway, where the hell did you do you research? Third world countries? Does anybody even sell a monitor that is only capable of 1024x768 any more?
Everything seems to be widescreen these days.
| null |
0
|
1317222073
|
False
|
0
|
c2n8acw
|
t3_ktenx
| null |
t1_c2n8acw
|
t1_c2n89bk
| null |
1427658180
|
-1
|
t5_2fwo
| null | null | null |
True
|
farnz
| null |
Back in the day, Python knowledge was rare. People who knew Python well tended to be the sorts of people who sought out new ways to do things, and kept up to date with what the bleeding edge has to offer.
Now, Python is commonplace; knowing Python just tells me you know Python, and doesn't come with the hint that you're probably the type of person who seeks out new ways to do things, and who constantly tries to improve their programming skills.
At some point, knowing Haskell may become similarly common - right now, though, knowing Haskell not only tells me that you know Haskell, but also tells me that you're the sort of person who looks into new ways to do things, and that you're not afraid of a challenge if you think it will help you improve as a programmer. By that point, there is almost certainly going to be a new hot thing (maybe a dependently typed language like Idris, maybe something that's not on my radar right now) that indicates that you seek out new ways to do things in the hope of improving your abilities.
| null |
0
|
1317222155
|
False
|
0
|
c2n8asx
|
t3_ktxzn
| null |
t1_c2n8asx
|
t1_c2n82xv
| null |
1427658179
|
21
|
t5_2fwo
| null | null | null |
True
|
snarfy
| null |
>Notice, 2/3 out of the roles on that list have nothing to do with programming or software development. It's a process created to give worthless, meaningless people a couple of jobs in saying "THIS IS WHAT THE BUSINESS NEEDS!"
Well look, I already told you! I deal with the goddamn customers so the engineers don't have to! I have people skills! I am good at dealing with people! Can't you understand that? What the hell is wrong with you people?
| null |
0
|
1317222179
|
False
|
0
|
c2n8awt
|
t3_ktxk5
| null |
t1_c2n8awt
|
t1_c2n796q
| null |
1427658182
|
9
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317222189
|
False
|
0
|
c2n8ayt
|
t3_ktv1z
| null |
t1_c2n8ayt
|
t1_c2n7ure
| null |
1427658182
|
1
|
t5_2fwo
| null | null | null |
True
|
Mikul
| null |
Agile means nothing. Like every other methodology, it takes on the personality of the team and the PM, but mainly the PM as he has control over more aspects of the project.
Agile doesn't work unless the Scrum Master has a real say in what does and doesn't happen. If the product owner micro manages every step, or the Scrum Master doesn't have a backbone, it will be a mess.
This leads to the most annoying thing I've ever seen where the daily sprint meeting was 45 minutes long eating up 22 hours of development time every week.
| null |
0
|
1317222241
|
False
|
0
|
c2n8b77
|
t3_ktxk5
| null |
t1_c2n8b77
|
t3_ktxk5
| null |
1427658191
|
12
|
t5_2fwo
| null | null | null |
True
|
chub79
| null |
"Too long to read" I guess.
| null |
0
|
1317222390
|
False
|
0
|
c2n8bzp
|
t3_ktxk5
| null |
t1_c2n8bzp
|
t1_c2n89k2
| null |
1427658192
|
2
|
t5_2fwo
| null | null | null |
True
|
elperroborrachotoo
| null |
1. *640K was laughable in the Windows 95 era.* IIRC it was a relevant test case. Anyway, the window manager goes back farther than that.
2. But you might have learned already that a *signal sent through the operating system* is not necessarily a signal to be sent by the client application.
3. All calls involved happens in userspace (Window Manager does not run in the kernel). The test "Is this WM_DESTROY sent from DestroyWindow" would have to be added to SendMessage and related functions (PostMessage, SendMessageTimeout, ...) - a very critical code path. The big cost of the change is not the number of characters to type, but potentially breaking some obscure application or use case.
4. Now we are at the interesting question
It's a design choice. Realize that the pre-Win95 Windows API was, by design, cooperative: if one program did the wrong thig, it would break the entire OS. So if you wrote a program, you had to make damn sure you didn't do the wrong thing.
Even "modern" API's of a certain complexity aren't foolproof. A reasonable design goal would be "make the right thing easier than the wrong thing". The Window Manager API fails *that* test in many instances.
Using your example: No API can protect you from writing to the wrong address, because it doesn't know what the wrong address is. It can merely give you tools (like page protection) to control yourself, and make the wrong thing hard (by automatically write-protecting ).
| null |
0
|
1317222390
|
False
|
0
|
c2n8bzw
|
t3_ktv1z
| null |
t1_c2n8bzw
|
t1_c2n7zso
| null |
1427658192
|
8
|
t5_2fwo
| null | null | null |
True
|
huyvanbin
| null |
I have a question. Why is it possible for game developers to discuss how their games worked so openly? I know in many companies there is a paranoia that make it impossible to publicly disclose anything about a product's internal workings. For example, I can't imagine a developer from Cadence writing an article about how their PCB layout engine works. Is the IP ownership different in the gaming industry?
| null |
0
|
1317222441
|
False
|
0
|
c2n8c8l
|
t3_ktd67
| null |
t1_c2n8c8l
|
t3_ktd67
| null |
1427658196
|
1
|
t5_2fwo
| null | null | null |
True
|
player2
| null |
And fuck up QA's sprint schedule?
Better to look at the sprint and realize your estimation error, and then begin a new sprint.
| null |
0
|
1317222476
|
False
|
0
|
c2n8cfi
|
t3_ktxk5
| null |
t1_c2n8cfi
|
t1_c2n82wf
| null |
1427658197
|
1
|
t5_2fwo
| null | null | null |
True
|
jones1618
| null |
Answers to the same question on Quora include a few good examples:
http://www.quora.com/What-are-some-real-world-applications-of-genetic-algorithms
Spam detection, marketing, container logistics, trading strategies, 3D character animation...
| null |
0
|
1317222548
|
False
|
0
|
c2n8csi
|
t3_ktg7o
| null |
t1_c2n8csi
|
t1_c2n568a
| null |
1427658202
|
1
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317222848
|
False
|
0
|
c2n8dpy
|
t3_ktg7o
| null |
t1_c2n8dpy
|
t1_c2n89w9
| null |
1427658215
|
1
|
t5_2fwo
| null | null | null |
True
|
grandfatha
| null |
You inspired me to implement my own version. I took two assumptions into my version of the mutate() method:
- Instead of replacing elements of the input string with complete random characters, only allow valid characters that appear in the target String and choose a random one on each mutation step.
- Dont change characters that are already correct.
By doing this, I got down to 120 iterations on average that are necessary to transform the input string into the target string.
Thank you for this article and for the inspiration to challenge myself with this.
| null |
0
|
1317222913
|
False
|
0
|
c2n8e2i
|
t3_ktg7o
| null |
t1_c2n8e2i
|
t3_ktg7o
| null |
1427658219
|
1
|
t5_2fwo
| null | null | null |
True
|
chub79
| null |
Indeed. Just because scrum provides you with the mean to voice concerns doesn't mean managers will listen to them anyhow.
| null |
0
|
1317222914
|
False
|
0
|
c2n8e32
|
t3_ktxk5
| null |
t1_c2n8e32
|
t1_c2n7w1t
| null |
1427658221
|
8
|
t5_2fwo
| null | null | null |
True
|
realmadrid2727
| null |
The first "Ramirez" I ever encountered in a video game.
| null |
0
|
1317222925
|
False
|
0
|
c2n8e80
|
t3_ktd67
| null |
t1_c2n8e80
|
t1_c2n2n5s
| null |
1427658221
|
2
|
t5_2fwo
| null | null | null |
True
|
The-Good-Doctor
| null |
Your mutation function only mutates a single character at a time. Would the algorithm reach its destination faster if two or more characters mutated at a time? That might be an interesting direction for continued exploration. You've managed to evolve a random string to a known answer, but why not try to evolve the algorithm to an unknown answer? Use as a fitness function the number of generations required to reach "hello world", and use different mutation parameters as the DNA. For example, if your mutation algorithm is modified to mutate X characters + or - a random value from 1 to Y, where X and Y comprise the DNA of your new genetic algorithm, what makes a good choice for X and Y to minimize the number of generations required to get to "hello world"?
| null |
0
|
1317222938
|
False
|
0
|
c2n8eas
|
t3_ktg7o
| null |
t1_c2n8eas
|
t3_ktg7o
| null |
1427658223
|
1
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317223033
|
False
|
0
|
c2n8et4
|
t3_kq27q
| null |
t1_c2n8et4
|
t1_c2mfgz3
| null |
1427658230
|
1
|
t5_2fwo
| null | null | null |
True
|
grandfatha
| null |
I did this in my version and it cuts down the # of required iterations a lot.
| null |
0
|
1317223076
|
False
|
0
|
c2n8f16
|
t3_ktg7o
| null |
t1_c2n8f16
|
t1_c2n8eas
| null |
1427658233
|
1
|
t5_2fwo
| null | null | null |
True
|
0xABADC0DA
| null |
You can get this anytime using menu item View -> Page Style -> No Style in Firefox.
Really comes in handy when the page has annoying layout and you just want to read the text.
| null |
0
|
1317223083
|
False
|
0
|
c2n8f2i
|
t3_ktd67
| null |
t1_c2n8f2i
|
t1_c2n4kji
| null |
1427658233
|
2
|
t5_2fwo
| null | null | null |
True
|
Rudy69
| null |
I got my book yesterday! Looks great, thanks!!!
| null |
0
|
1317223097
|
False
|
0
|
c2n8f5p
|
t3_jjcwd
| null |
t1_c2n8f5p
|
t3_jjcwd
| null |
1427658233
|
1
|
t5_2fwo
| null | null | null |
True
|
Leonidas_from_XIV
| null |
No, sorry if you got the impression that I wanted to misunderstand you. I just wanted to point out, that option 1 is way more likely to happen than option 2. And both are unlikely, unfortunately.
| null |
0
|
1317223190
|
False
|
0
|
c2n8foo
|
t3_kp1b5
| null |
t1_c2n8foo
|
t1_c2mfqne
| null |
1427658241
|
1
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
I agree.
What the hell are Sharpies and Biros?
| null |
0
|
1317223249
|
False
|
0
|
c2n8fxl
|
t3_ktxk5
| null |
t1_c2n8fxl
|
t1_c2n7kzf
| null |
1427658245
|
2
|
t5_2fwo
| null | null | null |
True
|
Amablue
| null |
That was my initial assumption too. I have two widescreen monitors at home and two more at work. I don't personally know anyone who uses 1024x768. However, the statistics show that there is a huge number of people still using 1024.
| null |
0
|
1317223296
|
False
|
0
|
c2n8g5r
|
t3_ktenx
| null |
t1_c2n8g5r
|
t1_c2n8acw
| null |
1427658247
|
2
|
t5_2fwo
| null | null | null |
True
|
binford2k
| null |
Reminder:
>Actually, I think he's asking for a justification for change.
Maybe this was that other khoury.
| null |
0
|
1317223302
|
False
|
0
|
c2n8g72
|
t3_krv1k
| null |
t1_c2n8g72
|
t1_c2n4do5
| null |
1427658249
|
1
|
t5_2fwo
| null | null | null |
True
|
jeff_skj
| null |
RE: Inaccurate planning at the beginning. We're actually improving a lot now.
We've found on our team the shortening the sprint cycle really helped with this, it's much easier to accurately plan for 2 weeks than it is for 4.
| null |
0
|
1317223346
|
False
|
0
|
c2n8ghm
|
t3_ktxk5
| null |
t1_c2n8ghm
|
t1_c2n7qcp
| null |
1427658251
|
2
|
t5_2fwo
| null | null | null |
True
|
Leonidas_from_XIV
| null |
Probably not (though you somehow need to pass the connection across process boundaries, not sure whether that works well), but why should you need to circumvent a limitation with multiple processes? It's like the Python GIL all over again, where they promote using `multiprocessing` (forking basically) to run more than one thread of Python code at the time. And yes, there are also similar solutions for Node.js already.
| null |
0
|
1317223358
|
False
|
0
|
c2n8gjy
|
t3_kq27q
| null |
t1_c2n8gjy
|
t1_c2mgbax
| null |
1427658252
|
1
|
t5_2fwo
| null | null | null |
True
|
henk53
| null |
JSF 2 is a gigantic improvement for sure. It also fully represents the change of teams. 1.0 and 1.1 were created and led by Craig McClanahan of Struts 'fame'. They were rather rubbish really.
For 1.2, Ed Burns took over, but there wasn't that much time left to fix things because of the Java EE 5 deadline in which JSF would be included. So the most glaring problems were fixed (particularly the insane content interweaving problem and the inability to easily invoke an operation on a component in context).
For 2.0, an unusual long time was taken to focus completely on fixing all damage done by 1.x. Nearly everything the community ever complained about was fixed.
It boils down to dumping JSP and making Facelets the default VDL, making it *really* easy to create custom components, making GET a first class citizen, using annotations to declare beans and other stuff, introducing the view scope, doing away with the requirement to define navigation rules in an xml file, doing away with the requirement to configure stuff in web.xml or faces-config.xml in order to start using JSF, making AJAX support available in the core framework (so that third party AJAX component libs can work together in a single page), and a bunch of other things.
With the 1.x damage being largely undone, the framework is now moving forward at a rapid pace. 2.1 was released shortly after 2.0, and 2.2 is due for end of this year.
>I have tried using it with Seam. That Seam makes using JSF tolerable is pretty amazing.
One of the few things that 1.x did right is being very extendable and assuming very little in the core. This is what made it relatively easy to create something like Facelets and Seam. In a way, Seam did not patch JSF, but Seam took advantage of the extension points JSF provided.
Things like Facelets, Seam, RichFaces, etc were actually envisioned by the original creators, so to their credit this is something they did right. It's just that they did a very lousy job for the default implementations of various parts.
| null |
0
|
1317223369
|
False
|
0
|
c2n8gm3
|
t3_kt682
| null |
t1_c2n8gm3
|
t1_c2n84mf
| null |
1427658252
|
8
|
t5_2fwo
| null | null | null |
True
|
Matemeo
| null |
While it's an interesting write-up, this is something that a Windows programmer damn well better know.
| null |
0
|
1317223384
|
False
|
0
|
c2n8gov
|
t3_ktv1z
| null |
t1_c2n8gov
|
t3_ktv1z
| null |
1427658253
|
3
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
I agree.
What the hell are Sharpies and Biros?
| null |
0
|
1317223409
|
False
|
0
|
c2n8gtk
|
t3_ktxk5
| null |
t1_c2n8gtk
|
t1_c2n7kzf
| null |
1427658255
|
0
|
t5_2fwo
| null | null | null |
True
|
cwstjnobbs
| null |
How are these stats collected?
Nobody ever asked me what resolution I use...
| null |
0
|
1317223414
|
False
|
0
|
c2n8guh
|
t3_ktenx
| null |
t1_c2n8guh
|
t1_c2n8g5r
| null |
1427658255
|
0
|
t5_2fwo
| null | null | null |
True
|
notSorella
| null |
Well, I would argue that ASI is by far the least of JS problems. AND, it is consistent and it makes sense, imho. Basically, all it says is that you can omit semicolons at the end of the statement, but a statement might be implicitly continued if the next source line starts with a continuation token, as it is most obviously a part of the previous statement. The exception being restricted productions (return, break, continue, prefix/postfix), where no line-break is permited between the statement keyword/token and the expression/label, otherwise it would clearly decrease readability.
I don't expect people to fully know everything about the technical specifications of a language. But I *do* expect that someone who is working with a language will actually take their time to learn it, rather than blaming the language design because of their lazyness.
Not saying that JS is a perfect language (I don't think there's such thing), there are clear semantic and design mistakes here and there, and I really don't consider ASI to be one of them. Otherwise, I would have to consider Python's particular design flawled on those regards as well.
| null |
0
|
1317223539
|
False
|
0
|
c2n8hiy
|
t3_kswql
| null |
t1_c2n8hiy
|
t1_c2n65g6
| null |
1427658264
|
1
|
t5_2fwo
| null | null | null |
True
|
somefriggingthing
| null |
Wouldn't reactive extensions be suitable for this? As long as you have some way of determining priority, you could order by that and consume the events.
| null |
0
|
1317223544
|
False
|
0
|
c2n8hki
|
t3_ku3ph
| null |
t1_c2n8hki
|
t1_c2n80pl
| null |
1427658265
|
1
|
t5_2fwo
| null | null | null |
True
|
axilmar
| null |
Not at all. What I said above is valid and true. Please try some programming in those two APIs and then we can talk.
| null |
0
|
1317223546
|
False
|
0
|
c2n8hks
|
t3_ktv1z
| null |
t1_c2n8hks
|
t1_c2n81ju
| null |
1427658265
|
-1
|
t5_2fwo
| null | null | null |
True
|
puresock
| null |
I've always worked on the principle that the product owner can't add anything to the sprint backlog, but if the developers get through the sprint backlog and pick some stuff off the top of the product backlog, that's a bonus.
That won't work for everyone, of course. Depends on the environment a lot.
| null |
0
|
1317223559
|
False
|
0
|
c2n8hno
|
t3_ktxk5
| null |
t1_c2n8hno
|
t1_c2n82wf
| null |
1427658266
|
8
|
t5_2fwo
| null | null | null |
True
|
mommathecat
| null |
Lol. You've never worked with assholes who don't give a flying shit about developer concerns. Assholes who will ignore what reality is telling them, that their idea is a pile of shit, and insist the solution is for people to work harder!
| null |
0
|
1317223575
|
False
|
0
|
c2n8hrj
|
t3_ktxk5
| null |
t1_c2n8hrj
|
t1_c2n7v5e
| null |
1427658267
|
14
|
t5_2fwo
| null | null | null |
True
|
yojoe26
| null |
Well, first of all, even the best developers cannot precisely estimate how much work is involved in stories 100% of the time. Plus Agile is supposed to be a flexible framework, meaning that everyone involved (including QA) should be able to adapt to changes in the sprint, including new stories.
We keep the same sprint length at all times and tend to underestimate the number of stories (to be on the safe side) at the beginning of each sprint and then pull in additional stories as necessary. The approval of QA, Product and Development is needed to do so but it's worked out pretty well.
| null |
0
|
1317223611
|
False
|
0
|
c2n8huk
|
t3_ktxk5
| null |
t1_c2n8huk
|
t1_c2n8cfi
| null |
1427658268
|
2
|
t5_2fwo
| null | null | null |
True
|
tactics
| null |
What does it do?
| null |
0
|
1317223631
|
False
|
0
|
c2n8i30
|
t3_ktxg3
| null |
t1_c2n8i30
|
t3_ktxg3
| null |
1427658271
|
2
|
t5_2fwo
| null | null | null |
True
|
AngryMathDave
| null |
I think a better biological definition of "end point" is to produce copies(offspring) of yourself. And by 'yourself', I roughly mean a gene. This definition is broader than yours and contains your 'dynamic' end point idea. The dynamic part can be interpreted as 'whatever it takes to make more copies of myself'.
In your experiment the strings are the genes, and the ability to create copies of yourself (decedents) is directly related to how close the string is to 'Hello World!'.
To answer PotsAndOwls question, I think the way to look at the experiment is that there is no 'end point' for the strings(genes). The experiment simply establishes a 'world' in which these strings(genes) live with a very explicit and simple definition of fitness (ability to have offspring).
| null |
0
|
1317223667
|
False
|
0
|
c2n8ib0
|
t3_ktg7o
| null |
t1_c2n8ib0
|
t1_c2n5tpw
| null |
1427658275
|
1
|
t5_2fwo
| null | null | null |
True
|
AeroNotix
| null |
Amazing response. Thanks.
| null |
0
|
1317223670
|
False
|
0
|
c2n8ibs
|
t3_ktxzn
| null |
t1_c2n8ibs
|
t1_c2n8asx
| null |
1427658276
|
1
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
A lot of people who claim to use Scrum actually don't. They are just using a buzzword to cover the fact that they are unorganized and don't do proper panning and design.
| null |
0
|
1317223676
|
False
|
0
|
c2n8ict
|
t3_ktxk5
| null |
t1_c2n8ict
|
t3_ktxk5
| null |
1427658276
|
24
|
t5_2fwo
| null | null | null |
True
|
mommathecat
| null |
> On top of that, the process usually assumes a developer knows absolutely everything about what it is they're trying to accomplish, and this is never the case.
This, SO much this.
"Estimate this fairly complicated feature that you really have no idea how long it's going to take."
Uhh, OK. Are.. you.. fisting me?
In my experience with Scrum/Agile, it's a way for management assholes to try and quantify productivity, when it actually decreases the amount of work that gets done, because you waste a bunch of time in story voting (fucking shoot me), daily scrums, sprint reviews, blah blah blah blah. I know, I know, we were "doing it wrong". That seems to be pretty common, innit? Maybe the problem is not a company's implementation of Scrum/Agile/whatever, it's that these processes are designed for an idealized, fantasy world that doesn't exist.
| null |
0
|
1317223707
|
False
|
0
|
c2n8iiq
|
t3_ktxk5
| null |
t1_c2n8iiq
|
t1_c2n796q
| null |
1427658278
|
6
|
t5_2fwo
| null | null | null |
True
|
Amablue
| null |
Automated survey of users' systems.
| null |
0
|
1317223725
|
False
|
0
|
c2n8ilw
|
t3_ktenx
| null |
t1_c2n8ilw
|
t1_c2n8guh
| null |
1427658279
|
2
|
t5_2fwo
| null | null | null |
True
|
MeatTenderizer
| null |
Oh damn, another project to put in the todo list...
| null |
0
|
1317223836
|
False
|
0
|
c2n8j59
|
t3_ku203
| null |
t1_c2n8j59
|
t3_ku203
| null |
1427658286
|
1
|
t5_2fwo
| null | null | null |
True
|
snarfy
| null |
You have to fight for good quality code. At the end of the day, all a software company has is its code base. Eliminating technical debt should always be a top priority. It adds no features, extends deadlines, and costs money, but it is absolutely vital to the longevity of any software company. As a developer, it is your job to fight for it.
Far too often I see mediocre developers shoehorn in feature after feature into a rickety code base to the point the entire thing falls apart and becomes unmaintainable. All estimates go out the window because nobody has any idea how long it will take to untangle the mess that resembles pieces of spaghetti glued together end to end. A rewrite becomes inevitable.
| null |
0
|
1317223890
|
False
|
0
|
c2n8jgt
|
t3_ktxk5
| null |
t1_c2n8jgt
|
t1_c2n7wu7
| null |
1427658290
|
2
|
t5_2fwo
| null | null | null |
True
|
pgngugmgg
| null |
that's still easy for evolutionists.
| null |
0
|
1317223893
|
False
|
0
|
c2n8jhf
|
t3_ktg7o
| null |
t1_c2n8jhf
|
t1_c2n69v6
| null |
1427658291
|
0
|
t5_2fwo
| null | null | null |
True
|
pnpbios
| null |
I've been doing win32 for a while and have tried to play around some in Xlib to experiment with writing a window manager. It's tough to find up to date documentation on Xlib, especially now that it looks like there might be a mass migration to Wayland in the near future, which I also have a tough time finding documentation on.
I never said Xlib was retarded, just archaic. The concept of a display server, while quite cool, is very outdated.
If you have some experience with Xlib, then I would definitely like to ask you a few questions relating to video overlays if you have some time. Send me a PM if you are feeling helpfull.
| null |
0
|
1317223903
|
False
|
0
|
c2n8jjl
|
t3_ktv1z
| null |
t1_c2n8jjl
|
t1_c2n8hks
| null |
1427658291
|
3
|
t5_2fwo
| null | null | null |
True
|
pgngugmgg
| null |
who was the first author of that "already been done"?
| null |
0
|
1317223937
|
False
|
0
|
c2n8jqz
|
t3_ktg7o
| null |
t1_c2n8jqz
|
t1_c2n6y79
| null |
1427658294
|
1
|
t5_2fwo
| null | null | null |
True
|
aaronla
| null |
Except that WM_GETTEXT doesn't do the same thing as GetWindowText. There's probably some case where your analogy holds, but this is not it.
| null |
0
|
1317223951
|
False
|
0
|
c2n8ju0
|
t3_ktv1z
| null |
t1_c2n8ju0
|
t1_c2n7u29
| null |
1427658295
|
13
|
t5_2fwo
| null | null | null |
True
|
argherna
| null |
Nice. But how about learning Vim, like most other people, in Vim??? Seriously.
| null |
0
|
1317223958
|
False
|
0
|
c2n8jv6
|
t3_ktenx
| null |
t1_c2n8jv6
|
t3_ktenx
| null |
1427658295
|
0
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317223991
|
False
|
0
|
c2n8k0l
|
t3_ktenx
| null |
t1_c2n8k0l
|
t1_c2n7b7e
| null |
1427658298
|
2
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
You can get a time estimate out of agile, by following the trendline... But that's all it is; an estimate, as it should be, really...
| null |
0
|
1317224036
|
False
|
0
|
c2n8kbi
|
t3_ktxk5
| null |
t1_c2n8kbi
|
t1_c2n7vsz
| null |
1427658301
|
5
|
t5_2fwo
| null | null | null |
True
|
i8beef
| null |
The problem with refactoring is that it is only an "easy" process when the program is designed right in the first place. For instance, when the program is written in true spaghetti code fashion, it's usually damn near impossible to really refactor without rewriting and redesigning a good portion of the system, and that is not a small feat especially when you have a larger team working on it at the same time.
I find that most of the times "refactoring" is near impossible until it's redesigned. **This is why designing things right in the first place is important**. I usually recommend DDD as a good framework for that. If you're just writing code without a good framework in mind of how to lay out the various parts of your system, you are probably setting yourself up for a maintainability nightmare.
The sad thing is, almost no one does this, and it's damn near impossible to justify a redesign to business people. That conversation usually goes like this:
"We need to redesign the application."
"What do we get out of it?"
"A better product that is easier to extend and maintain for the developers."
"So no new features or benefits that we can sell? Then no."
| null |
0
|
1317224142
|
False
|
0
|
c2n8kuh
|
t3_ktg8c
| null |
t1_c2n8kuh
|
t1_c2n77ca
| null |
1427658308
|
7
|
t5_2fwo
| null | null | null |
True
|
jimbokun
| null |
Worth reading for the slide about QuickCheck alone. Definitely making me rethink my entire testing strategy.
| null |
0
|
1317224169
|
False
|
0
|
c2n8l06
|
t3_ktxzn
| null |
t1_c2n8l06
|
t3_ktxzn
| null |
1427658310
|
5
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
Yeah, OP should use the number of generations this program requires as the input to a fitness function of another GA whose genome represents the inputs to this program (mutation rate, population size etc. although they aren't variable in the OP's program, that could be changed. I'm pretty sure mutation with every iteration is slowing down the evolution.)
| null |
0
|
1317224181
|
False
|
0
|
c2n8l2a
|
t3_ktg7o
| null |
t1_c2n8l2a
|
t1_c2n74oo
| null |
1427658311
|
1
|
t5_2fwo
| null | null | null |
True
|
pgngugmgg
| null |
that's the One tip that rules all.
| null |
0
|
1317224287
|
False
|
0
|
c2n8lnj
|
t3_ktg8c
| null |
t1_c2n8lnj
|
t1_c2n5ifp
| null |
1427658319
|
1
|
t5_2fwo
| null | null | null |
True
|
ISV_Damocles
| null |
My point with (2) is that *DestroyWindow* could just as easily have been a simple wrapper around sending the *WM_DESTROY* signal. If that's the action that should be taken, and the only valid use-case of sending that signal is actually destroying the window, then why wouldn't the signal-sending action itself trigger the window clean-up code?
Can you name a use-case where it makes any sense to tell a window it is being destroyed without actually destroying it? The window will enter a state where it is impossible for anything to be done with it, so isn't that just a memory leak? Again, if an application is broken by this change, it should be added the compatibility list and the developer contacted about the issue, if possible. Why go through the longer, harder pain of supporting these broken applications when trying to push the API forward, when you can just relegate it to the previous version of the API?
On (4), that just doesn't make sense. These are third-party applications that may or may not behave. The very origin of an operating system was to correct for misbehaving programs on timesharing servers -- the *purpose* of an operating system is to manage the system resources fairly amongst the running applications, which means that final decisions about resource usage should *always* fall on the OS.
It may be a "design" decision, but it's the wrong one. Period.
| null |
0
|
1317224469
|
False
|
0
|
c2n8ma1
|
t3_ktv1z
| null |
t1_c2n8ma1
|
t1_c2n8bzw
| null |
1427658326
|
-1
|
t5_2fwo
| null | null | null |
True
|
fnmatrix
| null |
I took an Evolutionary Programming class in college. There are some terms that would be good to add to the article. By keeping the "fittest" string or chromosome in the gene pool is called: **Elitism**. For selecting what the parents will be, there are multiple selection algorithms you can use: Tournament, Round Robin, and Roulette. Producing a child is done through performing **crossovers**. There are many different types of crossover algorithms: Order 1, Cycle, Cycle of length 3, Pairwise, etc. Additionally, there are ways to "simulate" a genetic algorithm and get a close approximate answer through **Simulated Annealing** and **Hill Climbing** (a foolish algorithm).
| null |
0
|
1317224487
|
False
|
0
|
c2n8mbf
|
t3_ktg7o
| null |
t1_c2n8mbf
|
t3_ktg7o
| null |
1427658326
|
1
|
t5_2fwo
| null | null | null |
True
|
eabrek
| null |
This is how I learned:
http://mislav.uniqpath.com/poignant-guide/
Chunky bacon!
| null |
0
|
1317224628
|
False
|
0
|
c2n8n73
|
t3_ku2z1
| null |
t1_c2n8n73
|
t3_ku2z1
| null |
1427658338
|
0
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
I applaud the best (and most sensible) come-back you could have used.
| null |
0
|
1317224658
|
False
|
0
|
c2n8nd0
|
t3_ktv1z
| null |
t1_c2n8nd0
|
t1_c2n81ju
| null |
1427658340
|
3
|
t5_2fwo
| null | null | null |
True
|
wreckerone
| null |
Problems are also:
3. Managers are sociopaths who think scrum tools are for them to set how many hours developers will get to fininsh a task they wrote. (yes, really)
| null |
0
|
1317224684
|
False
|
0
|
c2n8nhv
|
t3_ktxk5
| null |
t1_c2n8nhv
|
t1_c2n7k9l
| null |
1427658343
|
20
|
t5_2fwo
| null | null | null |
True
|
player2
| null |
Wait, your QA department isn't involved in your sprint planning?
| null |
0
|
1317224909
|
False
|
0
|
c2n8orx
|
t3_ktxk5
| null |
t1_c2n8orx
|
t1_c2n8huk
| null |
1427658359
|
0
|
t5_2fwo
| null | null | null |
True
|
lextenou
| null |
I use Agile Scrum. I have a framework that is complex and involved. It requires reproducible and customisible interfaces. It has to be scalable to accept a single department or the entire company. I feel that it is being used effectively. We do have two week sprints. We don't always deliver according to projected burndowns. But we also don't force ourselves to only do what is in the sprint. We block out 5 or 6 hours per day for sprint-related tasks, and if something comes up, like needing to reboot a production server or a system crashes because its overheated (fucking southern states...) we can take care of it immediately without impact on the sprint.
I dunno. I really like Agile Scrum, but the more I read about it, the more I'm realizing that I am in a really lucky position of actually having it implemented functionally. And in having a framework that requires reproducible work.
| null |
0
|
1317224926
|
False
|
0
|
c2n8oup
|
t3_ktxk5
| null |
t1_c2n8oup
|
t3_ktxk5
| null |
1427658360
|
4
|
t5_2fwo
| null | null | null |
True
|
typpeo
| null |
That's the friendliest error message I've ever received. PS It was from having Hardware Acceleration on in Flash which seems to fail every where.
| null |
0
|
1317224939
|
False
|
0
|
c2n8oxl
|
t3_ku6b2
| null |
t1_c2n8oxl
|
t3_ku6b2
| null |
1427658361
|
1
|
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.