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
|
ithika
| null |
"refactor" is advice much on a par with "don't write bugs" to be honest.
| null |
0
|
1317217151
|
False
|
0
|
c2n7p4w
|
t3_ktg8c
| null |
t1_c2n7p4w
|
t1_c2n7n1e
| null |
1427657892
|
3
|
t5_2fwo
| null | null | null |
True
|
Laziness
| null |
Just to throw out a few examples. Older games like Doom and Duke Nukem 3D used raycasting engines which rendered 2D maps in 3D using a single scanline to determine what to draw. Games like Quake introduced lighting and shading but it was all preprocessed; never rendered in realtime. And all of the older games made heavy use of 2D sprites to populate the 3D world with objects. Many games still use 2D sprites to this day.
An old but popular book by Michael Abrash goes into much greater detail about all of the tricks used back then. [Graphics Programming Black Book](http://books.google.com/books/about/Michael_Abrash_s_graphics_programming_bl.html?id=KnzQAAAACAAJ) if you're interested in more examples.
| null |
0
|
1317217167
|
False
|
0
|
c2n7p75
|
t3_ktd67
| null |
t1_c2n7p75
|
t1_c2n7h1f
| null |
1427657893
|
3
|
t5_2fwo
| null | null | null |
True
|
TankorSmash
| null |
Hahaha, I feel you there! Thanks.
| null |
0
|
1317217185
|
False
|
0
|
c2n7pa3
|
t3_ktg7o
| null |
t1_c2n7pa3
|
t1_c2n5yj5
| null |
1427657895
|
2
|
t5_2fwo
| null | null | null |
True
|
sawu
| null |
The exception might be a "high risk" product. A merchant might have 995/1000 positive ratings, after selling 995 boxes of tic-tacs, and frauding users out of 5 50" TVs. Bit of an exaggeration, but in principle it could be a factor.
| null |
0
|
1317217198
|
False
|
0
|
c2n7pbo
|
t3_ktx2g
| null |
t1_c2n7pbo
|
t1_c2n7jec
| null |
1427657896
|
3
|
t5_2fwo
| null | null | null |
True
|
datenwolf
| null |
> It's just that the rastering step (i.e. making a 2D image) is mostly left to hardware.
You're somewhat stuck in the late 1990ies. The NVidia TNT2 was the last GPU performing only the rasterizing step. Since the GeForces also all the geometry transformation happens on the GPU. GeForce2 provided some limited configurable fragment shading, technically register combining. But given enough patience and ideas one can render quite beautiful water with it. GeForce4 had the first hind of free programmability.
These days GPUs are freely programmable in each and every step. One can dynamically refine geometry with a custom program (tesselation shader), modify local topology (geometry shader), perform per vertex calculations (vertex shader) and finally operate in the screen space pixel level (fragment/pixel shaders).
| null |
0
|
1317217209
|
False
|
0
|
c2n7pdd
|
t3_ktd67
| null |
t1_c2n7pdd
|
t1_c2n69r5
| null |
1427657896
|
3
|
t5_2fwo
| null | null | null |
True
|
bitchessuck
| null |
maybe
| null |
0
|
1317217284
|
False
|
0
|
c2n7pns
|
t3_ktwk1
| null |
t1_c2n7pns
|
t1_c2n7nis
| null |
1427657899
|
-11
|
t5_2fwo
| null | null | null |
True
|
SciK
| null |
Oh. Not sure I want to use Flash. But thanks. :)
| null |
0
|
1317217307
|
False
|
0
|
c2n7pqu
|
t3_kssyt
| null |
t1_c2n7pqu
|
t1_c2n2ekp
| null |
1427657900
|
1
|
t5_2fwo
| null | null | null |
True
|
killerstorm
| null |
Why can't developers just inform Product Owner and Scrum Master that product is going to be broken if they continue this way? If they don't give a fuck then they'll get what they deserve.
| null |
0
|
1317217327
|
False
|
0
|
c2n7pt6
|
t3_ktxk5
| null |
t1_c2n7pt6
|
t3_ktxk5
| null |
1427657901
|
2
|
t5_2fwo
| null | null | null |
True
|
corbet
| null |
Session reuse is at the core of the recently-disclosed TLS vulnerability. I've not looked closely enough here to form an opinion of whether the technique advocated could open up the same kind of problem, but I'd sure think carefully before actually implementing it.
| null |
0
|
1317217378
|
False
|
0
|
c2n7q0c
|
t3_kttwb
| null |
t1_c2n7q0c
|
t3_kttwb
| null |
1427657904
|
5
|
t5_2fwo
| null | null | null |
True
|
name_was_taken
| null |
Don't look at the good reviews. They're meaningless because it just means there was no problem. Instead, look for the bad reviews. They'll tell you what's wrong with the company and how they treat customers.
| null |
0
|
1317217451
|
False
|
0
|
c2n7q9f
|
t3_ktx2g
| null |
t1_c2n7q9f
|
t3_ktx2g
| null |
1427657908
|
8
|
t5_2fwo
| null | null | null |
True
|
dirtiest_dru
| null |
>I want to jump forward 3 words? I click my mouse 3 words ahead
You may also want to try Ctrl+(arrow key forward) three times. Unless your hands move at ninja speeds while operating the mouse, I feel like this is always faster.
| null |
0
|
1317217458
|
False
|
0
|
c2n7qaf
|
t3_ktenx
| null |
t1_c2n7qaf
|
t1_c2n5v70
| null |
1427657908
|
3
|
t5_2fwo
| null | null | null |
True
|
trigonomitron
| null |
Sometimes you need a process to do something, and the user doesn't need to interact with or even see it.
| null |
0
|
1317217467
|
False
|
0
|
c2n7qbh
|
t3_ktv1z
| null |
t1_c2n7qbh
|
t1_c2n7njb
| null |
1427657909
|
1
|
t5_2fwo
| null | null | null |
True
|
kazimir34
| null |
I've been working with Scrum for about 3 years now, and if implemented well, this can be very good.
Positive side:
* Prioritized backlog at all times, everyone in the team knows what is going to happen next and can give ideas / feeback to the product owner
* Team members feel like they can choose what they do, or at least have a little more freedom and feel more empowered
* Nothing is added in the middle of a Sprint
* The planning takes 2 meetings of 2 hours for a 4 week sprint, everyone participates
* We always have at least 2 people able to work on any task, if anybody goes on Holidays, the whole project isn't blocked
* Features are not closed until fully tested
Negative side:
* Inaccurate planning at the beginning. We're actually improving a lot now.
Seriously, Scrum implemented properly can be great.
*edit: also, RETROSPECTIVES! This is one of the most important part of Scrum. The team should be happy about Scrum or improve it during the retrospectives, that's the Scrum Master's job.
| null |
0
|
1317217477
|
True
|
0
|
c2n7qcp
|
t3_ktxk5
| null |
t1_c2n7qcp
|
t3_ktxk5
| null |
1427657909
|
63
|
t5_2fwo
| null | null | null |
True
|
stonefarfalle
| null |
There was an article a while back where someone used GAs to determine the best compiler settings for an application. I want to say it was written in Haskell and targeted gcc's settings, but I don't really remember.
| null |
0
|
1317217520
|
False
|
0
|
c2n7qi3
|
t3_ktg7o
| null |
t1_c2n7qi3
|
t1_c2n74oo
| null |
1427657910
|
4
|
t5_2fwo
| null | null | null |
True
|
syslog2000
| null |
I'm sure your boss loves you too.
| null |
0
|
1317217542
|
False
|
0
|
c2n7qkx
|
t3_ktxk5
| null |
t1_c2n7qkx
|
t1_c2n7hxr
| null |
1427657912
|
7
|
t5_2fwo
| null | null | null |
True
|
terremoto
| null |
What do you consider "normal?"
| null |
0
|
1317217568
|
False
|
0
|
c2n7qoh
|
t3_ktx2g
| null |
t1_c2n7qoh
|
t1_c2n7hen
| null |
1427657913
|
1
|
t5_2fwo
| null | null | null |
True
|
day_cq
| null |
TL;DR Haskell libraries we needed were not suitable or missing so we wrote them and they are available for you to download. And, writing them was like in 1994 due to lack of IDE and tools. But it's all good.
| null |
0
|
1317217660
|
False
|
0
|
c2n7r15
|
t3_ktxzn
| null |
t1_c2n7r15
|
t3_ktxzn
| null |
1427657918
|
-3
|
t5_2fwo
| null | null | null |
True
|
MyAtari2600IsSmarter
| null |
/r/programming is not a place to ask for help, run polls, rant, demo your app (unless your demo includes code or architecture discussion), or otherwise use as a captive audience.
| null |
0
|
1317217672
|
False
|
0
|
c2n7r2r
|
t3_ku175
| null |
t1_c2n7r2r
|
t3_ku175
| null |
1427657918
|
1
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
:o Science!
| null |
0
|
1317217718
|
False
|
0
|
c2n7r8s
|
t3_ku203
| null |
t1_c2n7r8s
|
t3_ku203
| null |
1427657921
|
1
|
t5_2fwo
| null | null | null |
True
|
nemtrif
| null |
> I've never heard a good explanation as to why using a tron era text editor makes me more productive than a well functioned IDE like eclipse or something similar to get my code done.
Depends on what you are exactly doing. For instance, if you are crafting a UI, then of course a "visual" IDE is the right tool for the job. If you mostly enter or edit code, then the code editor is where the action happens, and editors that come with IDEs by default are generally *far* behind vim. In theory, the best of both worlds would be to have a vim plugin for your favorite IDE, and I do use one for Visual Studio, but these plugins are really half-baked and buggy.
Another thing to consider is that an IDE such as eclipse can be very helpful with statically typed languages - much less so with dynamic ones (Smalltalk being an exception simply because the IDE is a part of the runtime).
| null |
0
|
1317217725
|
False
|
0
|
c2n7r9r
|
t3_ktenx
| null |
t1_c2n7r9r
|
t1_c2n5v70
| null |
1427657921
|
1
|
t5_2fwo
| null | null | null |
True
|
SciK
| null |
> * the Haskell IDEs and tools suck (except QuickCheck, which is awesome) but it's bearable
He didn’t talk about tools except QuickCheck and GHCi, only IDEs.
It seems to me that Haskell does have good tools: GHCi, Cabal, Darcs, HPC, SourceGraph…
| null |
0
|
1317217795
|
False
|
0
|
c2n7rj3
|
t3_ktxzn
| null |
t1_c2n7rj3
|
t1_c2n7b54
| null |
1427657925
|
15
|
t5_2fwo
| null | null | null |
True
|
day_cq
| null |
you cannot predict the future. But, you can learn from history and use what you learned so far to guide the project for better. Or, you can be a hipster cynic and (╯‵Д′)╯彡┻━┻ and cry out emo tears.
| null |
0
|
1317217818
|
False
|
0
|
c2n7rmb
|
t3_ktxk5
| null |
t1_c2n7rmb
|
t1_c2n7oqc
| null |
1427657926
|
-5
|
t5_2fwo
| null | null | null |
True
|
pnpbios
| null |
In windows everything inherits from a window. Buttons, check boxes, text areas, it's all technically a window. Each window handles it's own messages, and responds in kind.
You would need an invisible window if you were hooking for global shortcut keys in the background for something like begin record / end record. You wouldn't actually want the recording program visible when doing the recording, right?
| null |
0
|
1317217828
|
False
|
0
|
c2n7rno
|
t3_ktv1z
| null |
t1_c2n7rno
|
t1_c2n7njb
| null |
1427657926
|
11
|
t5_2fwo
| null | null | null |
True
|
metalmutt
| null |
My favorite story I heard about this was someone created a 40 meter long pool, and left a ga running overnight to have the computer create a "swimmer".
In the end the best swimmer it decided was a lopsided 40 meter tall stick that would just fall and make a bridge.
| null |
0
|
1317217832
|
False
|
0
|
c2n7roa
|
t3_ktg7o
| null |
t1_c2n7roa
|
t1_c2n4an4
| null |
1427657926
|
1
|
t5_2fwo
| null | null | null |
True
|
TomorrowPlusX
| null |
> Would be cool, any indication yet that this is happening?
Moore's law seems to be winding down, but people still want apps to do more and to do more with less ( think phones, tablets, etc ).
VMs will get better, but until then, for performance C++ is still (one) king for a number of problem domains. Not all, obviously. But still, it's a language that's well taught, and has good compilers and good toolchains.
C++ is an ugly broken language, but god damn code written in it *can* be fast.
| null |
0
|
1317217923
|
False
|
0
|
c2n7s1d
|
t3_kteac
| null |
t1_c2n7s1d
|
t1_c2n6t72
| null |
1427657931
|
2
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
Rather than blog about it, they should clarify the documentation for WM_DESTROY.
| null |
0
|
1317217962
|
False
|
0
|
c2n7s6w
|
t3_ktv1z
| null |
t1_c2n7s6w
|
t3_ktv1z
| null |
1427657934
|
-7
|
t5_2fwo
| null | null | null |
True
|
Reaper666
| null |
http://www.cleveralgorithms.com/
| null |
0
|
1317217976
|
False
|
0
|
c2n7s9b
|
t3_ktg7o
| null |
t1_c2n7s9b
|
t1_c2n6ub4
| null |
1427657935
|
2
|
t5_2fwo
| null | null | null |
True
|
friedrice5005
| null |
the .nanorc has an option to prevent that.
>set/unset nowrap: Don't wrap text at all.
[source](http://www.nano-editor.org/dist/v1.2/nanorc.5.html)
| null |
0
|
1317218002
|
False
|
0
|
c2n7sct
|
t3_ktenx
| null |
t1_c2n7sct
|
t1_c2n6dsd
| null |
1427657936
|
1
|
t5_2fwo
| null | null | null |
True
|
davvblack
| null |
MDX_AC_LAUGHTER_REAL_STIFLED is the new one.
| null |
0
|
1317218072
|
False
|
0
|
c2n7smc
|
t3_ktv1z
| null |
t1_c2n7smc
|
t1_c2n7mxt
| null |
1427657938
|
4
|
t5_2fwo
| null | null | null |
True
|
pnpbios
| null |
That's what WinRT is for!
It's not retarded, it's just old. For other examples of old APIs that need to be put to rest, see XLIB, which is just as archaic.
| null |
0
|
1317218115
|
False
|
0
|
c2n7srl
|
t3_ktv1z
| null |
t1_c2n7srl
|
t1_c2n764s
| null |
1427657941
|
4
|
t5_2fwo
| null | null | null |
True
|
sausagefeet
| null |
Agreed. If you make the example more contrived and say that WM_CREATE is sent during the destruction process, saying "Oh you should have read the docs" isn't a valid answer there. I think subtle things like WM_DESTROY vs WM_DESTROYING are more vicious though because WM_CREATE being sent during destruction simply makes no sense at all so you would check docs. DESTROY vs DESTROYING is far easier to convince yourself of the lie.
| null |
0
|
1317218174
|
False
|
0
|
c2n7szg
|
t3_ktv1z
| null |
t1_c2n7szg
|
t1_c2n7otu
| null |
1427657944
|
1
|
t5_2fwo
| null | null | null |
True
|
jplindstrom
| null |
Their pain is deferred. The pain of developers is immediate.
| null |
0
|
1317218198
|
False
|
0
|
c2n7t2z
|
t3_ktxk5
| null |
t1_c2n7t2z
|
t1_c2n7pt6
| null |
1427657945
|
10
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317218200
|
False
|
0
|
c2n7t3a
|
t3_ku203
| null |
t1_c2n7t3a
|
t3_ku203
| null |
1427657945
|
100
|
t5_2fwo
| null | null | null |
True
|
imbcmdth
| null |
99% of users don't read (or understand) dialog boxes so this would still be a huge security or usability issue for 99% of all users.
| null |
0
|
1317218208
|
False
|
0
|
c2n7t4g
|
t3_ksdfr
| null |
t1_c2n7t4g
|
t1_c2n1wpp
| null |
1427657946
|
1
|
t5_2fwo
| null | null | null |
True
|
day_cq
| null |
i bet your code base smells. write better code. it does help estimation.
| null |
0
|
1317218245
|
False
|
0
|
c2n7t92
|
t3_ktxk5
| null |
t1_c2n7t92
|
t1_c2n7oxw
| null |
1427657948
|
-15
|
t5_2fwo
| null | null | null |
True
|
Farfecknugat
| null |
Or just use non-statistical decision making like a real human
| null |
0
|
1317218249
|
False
|
0
|
c2n7t9f
|
t3_ktx2g
| null |
t1_c2n7t9f
|
t3_ktx2g
| null |
1427657948
|
-7
|
t5_2fwo
| null | null | null |
True
|
ISV_Damocles
| null |
I thought that's what the compatibility lists introduced in XP were about? For singled-out applications that do things the wrong way, but are widespread in usage, automatically revert the API to older behavior.
I can't see any *valid* use-case of sending the *WM_DESTROY* signal, since nothing but the kernel should be able to perform the memory-management actions in the first place, and this *does* lead to memory leaks that can only be solved by a reboot.
Linux and BSD have a reputation for being able to run solidly for *years* without a reboot, despite the far more fractured development process. I am a Linux fan, but theoretically Microsoft, being a sole controlling entity of the kernel, OS APIs, window manager, and even many of the programming languages the userland code is actually written in, should have a far easier time of making Windows faster and more stable than Linux because there's no-one else actually doing the development work to tug Windows into another direction.
This is why people think of Microsoft as a dinosaur and a joke, nowadays: design-by-committee (Linux, BSD) is producing a more solid foundation for servers than they are, and that's why start-ups are flocking to it (cheaper, more stable, faster [can cut out cruft you don't need, can recompile key components to use latest available instruction set], just have to use a command-line interface).
Android has shown that Windows only has its place, anymore, because of vendor lock-in, not anything particular about Windows itself (Android interface is nothing like Windows, so familiarity is not the problem, it's the available apps that's the problem, and Win Phone doesn't have them).
So, basically disappointed that the largest conglomeration of Computer Scientists and Software Engineers in the world is not driving computing forward like it could -- this API flaw is just one symptom of a much larger disease.
| null |
0
|
1317218273
|
False
|
0
|
c2n7tc6
|
t3_ktv1z
| null |
t1_c2n7tc6
|
t1_c2n7ktd
| null |
1427657949
|
-11
|
t5_2fwo
| null | null | null |
True
|
Killerkarpfen
| null |
I'm in software development for well over 10 years. The initial transition phase from waterfall to Scrum was nice and it looked promising. Then moronic project managers with shiny scrum master certificates were hired and it all went downhill.
Detached and non-content aware managers and "normal" developers never work well together, no matter the development method used.
| null |
0
|
1317218323
|
False
|
0
|
c2n7tjw
|
t3_ktxk5
| null |
t1_c2n7tjw
|
t3_ktxk5
| null |
1427657950
|
29
|
t5_2fwo
| null | null | null |
True
|
tdrgabi
| null |
no, you are not the only one
how does he connect the machines, what machines is he using to record this?
maybe it's mentioned somewhere in the blog, but I couldn't find it
| null |
0
|
1317218324
|
False
|
0
|
c2n7tk7
|
t3_ku203
| null |
t1_c2n7tk7
|
t1_c2n7t3a
| null |
1427657951
|
43
|
t5_2fwo
| null | null | null |
True
|
mccoyn
| null |
Agreed 100%. WM_GETTEXT does the same thing as GetWindowText. It is only natural to assume that other pairs do the same thing, that DestroyWindow does the same thing as WM_DESTROY. It is inconsistent.
| null |
0
|
1317218440
|
False
|
0
|
c2n7u29
|
t3_ktv1z
| null |
t1_c2n7u29
|
t1_c2n73fj
| null |
1427657957
|
2
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317218446
|
False
|
0
|
c2n7u3h
|
t3_ktxzn
| null |
t1_c2n7u3h
|
t3_ktxzn
| null |
1427657958
|
-12
|
t5_2fwo
| null | null | null |
True
|
Killerkarpfen
| null |
If you are in video game development you will have a hard time avoiding this these days.
| null |
0
|
1317218463
|
False
|
0
|
c2n7u64
|
t3_ktxk5
| null |
t1_c2n7u64
|
t1_c2n76qv
| null |
1427657958
|
1
|
t5_2fwo
| null | null | null |
True
|
serudla
| null |
that's a good article (though google's translation to English is a bit rough). it did not leave me liking JSF any better though.
popularity polls seem worthless, they just measure people's prejudices.
| null |
0
|
1317218473
|
False
|
0
|
c2n7u7b
|
t3_kt682
| null |
t1_c2n7u7b
|
t1_c2n6rrq
| null |
1427657959
|
0
|
t5_2fwo
| null | null | null |
True
|
albert_crowley
| null |
WIn32 Window objects has all the scaffolding built in to process incoming messages. If you want to create a thread that can receive communication from other parts of the system, sub-classing a Window lets you skip over all the required pluming needed to send and receive messages. With that out of the way you can get down to coding the functions you need in the thread.
| null |
0
|
1317218485
|
False
|
0
|
c2n7u9b
|
t3_ktv1z
| null |
t1_c2n7u9b
|
t1_c2n7njb
| null |
1427657960
|
8
|
t5_2fwo
| null | null | null |
True
|
Kracus
| null |
Yeah... I can tell someone likes to program.
| null |
0
|
1317218588
|
False
|
0
|
c2n7uni
|
t3_ktx2g
| null |
t1_c2n7uni
|
t3_ktx2g
| null |
1427657965
|
-8
|
t5_2fwo
| null | null | null |
True
|
alekseykorzun
| null |
What's wrong with 4 day sprints if they are needed? If it was for a critical piece of infrastructure that's acceptable. If it was not it's YOUR job to say NO.
That's called daily stand up and is part of Scrum. Again not sure what's your point.
If it's a critical issue, things can be added to sprint as a hot fix. If it's not, again it's your job to say no.
Seems to be you are one of 'those' developers.
| null |
0
|
1317218598
|
False
|
0
|
c2n7uot
|
t3_ktxk5
| null |
t1_c2n7uot
|
t1_c2n7hxr
| null |
1427657965
|
17
|
t5_2fwo
| null | null | null |
True
|
myztry
| null |
Having come from the purpose built (from scratch) Amiga OS, I found the whole win32 design disgustingly amateur. From the pop active to front behavior stemming from the Windows QDOS extender's original inability to render anything other than a foreground windows, to the lack of a window manager (like amiga's intuition).
Requiring applications to handle all invalidation rendering via wm_paint messages wasn't providing a window manager. It's a friction window FRAME manager at best with the window manager hardcoded into each and every windows application. I mean, you could take that approach on the Amiga if you wanted for some reason to manage your own window invalidation. It was an optional mode along with others like oversized "super" bitmaps. Since intuition provided a hardware (blitter) accelerated window manager, it was rarely a wise choice.
Then there was the distinct lack of "multi document" applications on Window as the the shitty mono-tasking inherited systems did not support object orientated concepts which allowed the same code to be used for different window "objects". So called "multi document" applications were common on the Amiga since the were so easy to implement on a well designed system a decade before Microsoft even figured out how to retro-fit pre-emotive multitasking in their system.
Granted, the Amiga did not have to worry about things like un-privileged (user) code "pranking" privileged (kernel) code since a MMU (memory management unit) which is essential for such things was decidedly out of budget when bringing modern paradigm personal computing to the masses, unlike big budget business machines like the IBM branded PC. It is really quite pathetic and telling of Microsoft's design skills (granted, from such a rubbishy base) that this is even possible on current era systems.
The most exciting thing about the likes of Apple and Google having so much success is not merely their products but the fact they give hope that the rubbish accumulated over decades may be purged. I welcome Windows 8 and it's ill conceived retro-fitted "me too" as the more desperate Microsoft gets, the more likely they are to fall from what once seemed like an insurmountable market position granted be a long lamented and unrepeatable dumb mistake (accepting license) by IBM to a mere software parts supplier.
| null |
0
|
1317218615
|
False
|
0
|
c2n7ure
|
t3_ktv1z
| null |
t1_c2n7ure
|
t3_ktv1z
| null |
1427657966
|
3
|
t5_2fwo
| null | null | null |
True
|
rafekett
| null |
My program was mostly Java up until a few years ago, until they went back to their ML roots (apparently they taught ML and C exclusively in the 80's).
| null |
0
|
1317218714
|
False
|
0
|
c2n7v53
|
t3_kteac
| null |
t1_c2n7v53
|
t1_c2n7euv
| null |
1427657971
|
2
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317218715
|
False
|
0
|
c2n7v5e
|
t3_ktxk5
| null |
t1_c2n7v5e
|
t1_c2n7tjw
| null |
1427657971
|
0
|
t5_2fwo
| null | null | null |
True
|
elperroborrachotoo
| null |
Some messages are to be sent by you, some are not.
The documentation doesn't spell it out in big bold burning lettes, but when you know that difference matters, the information is there for you.
| null |
0
|
1317218757
|
False
|
0
|
c2n7vat
|
t3_ktv1z
| null |
t1_c2n7vat
|
t1_c2n73fj
| null |
1427657973
|
3
|
t5_2fwo
| null | null | null |
True
|
wwwwolf
| null |
> Why should it even be possible for userspace code to send such a signal if the API depends on it being sent only via the DestroyWindow function?
Oh, perhaps it's just better to allow anything send any signals they want - even if it's up to the receiver to properly handle each signal. A better question would be why an obviously internal-use-only signal is given a handy global name that basically screams "ooo, you can use this signal to destroy windows". Would have been better to call it something like `WM_INTERNAL_DESTROY` and put "if you want to send this signal, you *must* use `DestroyWindow()`, all other use is bound to be problematic" in docs.
| null |
0
|
1317218793
|
False
|
0
|
c2n7vg3
|
t3_ktv1z
| null |
t1_c2n7vg3
|
t1_c2n7c3u
| null |
1427657976
|
6
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317218810
|
False
|
0
|
c2n7vj7
|
t3_ku203
| null |
t1_c2n7vj7
|
t3_ku203
| null |
1427657977
|
3
|
t5_2fwo
| null | null | null |
True
|
banuday
| null |
> AGILE fails because a developer cannot accurately tell anyone how long a particular feature might take them to make
The key point in Agile is that developers estimate on complexity, not time. Story points *are not* time units.
> especially if it's something obscure that they don't really use, or more importantly, maybe have never used.
In this case, the solution is to use large story points.
> Processes like these put too much of the power of saying what and
> when something gets developed into the hands of people who have
> no idea what they're doing.
Developers in Agile do not specify *what* gets delivered, that between the Product Owner and the Project Manager. Agile never says *when* something will get delivered, because it is not about delivering time estimates. In Agile, you Time Box or you Feature Box. When you Time Box, the deadline is fixed and the feature set variable. When you Feature Box, the feature set is fixed and the deadline variable.
> Business Analysts are some of the most bullshit jobs ever and most
> people aren't any better at it than the developer himself.
What a conceited thing to say. The Business Analysts I work with are some of the most valuable people on our team, and we hire people who have worked in the domain we are building software for, so they bring valuable domain knowledge to the team.
> using this process promotes you to offshore raw development as a service,
No, Agile requires face-to-face contact for maximum communication, since communication is the largest part of Agile.
> relegates programmers to being "code monkeys"
Absolutely not, it gives developers more responsibility.
| null |
0
|
1317218878
|
False
|
0
|
c2n7vsz
|
t3_ktxk5
| null |
t1_c2n7vsz
|
t1_c2n796q
| null |
1427657980
|
28
|
t5_2fwo
| null | null | null |
True
|
Killerkarpfen
| null |
Which is when the project managers don't listen and go crying to upper management that the devs are rebels against the shiny new answer to all the companies problem that scrum is usually sold as.
| null |
0
|
1317218950
|
False
|
0
|
c2n7w1t
|
t3_ktxk5
| null |
t1_c2n7w1t
|
t1_c2n7v5e
| null |
1427657984
|
19
|
t5_2fwo
| null | null | null |
True
|
cwstjnobbs
| null |
I would call it honesty but OK then.
| null |
0
|
1317219004
|
False
|
0
|
c2n7wa7
|
t3_ktenx
| null |
t1_c2n7wa7
|
t1_c2n7o6x
| null |
1427657987
|
2
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
If I understood the BEAST attack correctly, there is an offending JS that carries out the exploit.
| null |
0
|
1317219030
|
False
|
0
|
c2n7we0
|
t3_kttwb
| null |
t1_c2n7we0
|
t1_c2n7q0c
| null |
1427657989
|
1
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317219064
|
False
|
0
|
c2n7wjt
|
t3_kteac
| null |
t1_c2n7wjt
|
t1_c2n3i23
| null |
1427657994
|
1
|
t5_2fwo
| null | null | null |
True
|
elperroborrachotoo
| null |
1. The window manager was designed to run on machines with 640K RAM.
2. The window manager API was designed when people were still reading documentation
3. Any change in later revisions is a huge backward compatibility burden, and must be weighted against the actual benefits.
4. The Windows API does not try to prevent you from doing the wrong thing. It assumes that if you want to do the wrogn thing, you will do.
| null |
0
|
1317219077
|
False
|
0
|
c2n7wlx
|
t3_ktv1z
| null |
t1_c2n7wlx
|
t1_c2n7c3u
| null |
1427657991
|
16
|
t5_2fwo
| null | null | null |
True
|
createanewacct5
| null |
Designer (user experience) here: you're wrong. It's about only showing the *relevant* options, the rest is clutter and pointless to waste space on. The user is able to work more efficiently if they're not bogged down with the options they don't need. As a bonus, the UI ends up being more aesthetically pleasing and less intimidating for beginners. If the user needs more advanced options, there always "advanced" panels, keyboard shortcuts and CLI, but those are cleverly hidden away for the 99% of users that don't need them. And GIMP does have a shit interface. I'd know, I've tried it several times but still end up paying Adobe thousands for access to The Creative Suite. In the end, developers need to understand their audience before they build something. They didn't here. And they didn't in Linux. At least Ubuntu is trying to fix these issues.
| null |
0
|
1317219087
|
False
|
0
|
c2n7wnz
|
t3_jxzmt
| null |
t1_c2n7wnz
|
t1_c2g2aqq
| null |
1427657993
|
3
|
t5_2fwo
| null | null | null |
True
|
saksida
| null |
* vi is available everywhere. Last week I had to fix a ~15 years old script in a legacy AIX box. That setup doesn't have emacs. It doesn't even have pico. Just ed and vi - I checked. Knowing vi is a valuable asset if you have to deal with legacy systems.
* For languages with limited IDE support, it doesn't matter how many chunks of RAM your editor reserves for smart code completion features. The only thing that matters is how comfortable you are when *editing text*.
* When it comes to editing text, vi(m) shines. Most of the editor's features are related to text manipulation. I have yet to meet an IDE user who can complete a text-editing task for a given file faster than a seasoned vi user. Vi emulation exists for a reason. How quickly can you do a regexp search-and-replace using vanilla Visual Studio? I can do it in a couple of seconds with ViEmu.
Of course, learning vi is hard. You can hardly 'try' vi - you stick to it until it's part of your muscle memory. That's when you truly become productive with it, and that's when you decide whether or not you like it. So yeah, if you don't have to do a lot of text editing work, you probably have no good reason to learn it.
| null |
0
|
1317219089
|
False
|
0
|
c2n7wod
|
t3_ktenx
| null |
t1_c2n7wod
|
t1_c2n5v70
| null |
1427657993
|
3
|
t5_2fwo
| null | null | null |
True
|
chuckcallebs
| null |
Very interesting. I plan on trying this out tonight. I have an app I need to build and was debating on the implementation language.
| null |
0
|
1317219106
|
False
|
0
|
c2n7wqz
|
t3_kteac
| null |
t1_c2n7wqz
|
t1_c2n2ycz
| null |
1427657994
|
1
|
t5_2fwo
| null | null | null |
True
|
grelphy
| null |
Find me a code base that *doesn't* smell. It's a fact of life, and unless you're willing to put in the work to correct it all (and more importantly, your employer is willing to *pay* you to put in that work, which they're not), it's going to stay that way.
A good codebase is what you get when one or a very small group of developers have complete control. This simply doesn't happen in commercial environments over a certain (very small) size.
| null |
0
|
1317219129
|
False
|
0
|
c2n7wu7
|
t3_ktxk5
| null |
t1_c2n7wu7
|
t1_c2n7t92
| null |
1427657994
|
11
|
t5_2fwo
| null | null | null |
True
|
elperroborrachotoo
| null |
WM_DESTROY: [Sent when a window is being destroyed.](http://msdn.microsoft.com/en-us/library/windows/desktop/ms632620(v=vs.85\).aspx). Also references DestroyWindow.
Raymond Chen does not write for MSDN. His blog is his personal endeavor.
| null |
0
|
1317219231
|
False
|
0
|
c2n7xaf
|
t3_ktv1z
| null |
t1_c2n7xaf
|
t1_c2n7s6w
| null |
1427658000
|
12
|
t5_2fwo
| null | null | null |
True
|
lispchainsawmassacre
| null |
You can't decide anything by using Bayes rule in isolation. Doesn't this need a splash of decision theory?
E.g. if I am sufficiently risk averse & wanting to purchase 5000 books, choosing the first reseller might be the optimal decision from my perspective.
| null |
0
|
1317219274
|
False
|
0
|
c2n7xhm
|
t3_ktx2g
| null |
t1_c2n7xhm
|
t3_ktx2g
| null |
1427658002
|
2
|
t5_2fwo
| null | null | null |
True
|
almbfsek
| null |
where is the software and what kind of hardware/sensors did you use?
I would also like to record my sleep data
| null |
0
|
1317219287
|
True
|
0
|
c2n7xjv
|
t3_ku203
| null |
t1_c2n7xjv
|
t3_ku203
| null |
1427658003
|
7
|
t5_2fwo
| null | null | null |
True
|
chneukirchen
| null |
I don't get it. I let emacs indent my code and when I do
for(foo;bar;baz);
quux; // and press TAB here, it doesn't indent, and I notice the code is wrong
if (a)
if (b)
c;
else // and press TAB here, and I see exactly how the code is parsed
Just let the editor indent semantically, and the meaning is clear.
| null |
0
|
1317219291
|
False
|
0
|
c2n7xke
|
t3_kooiy
| null |
t1_c2n7xke
|
t1_c2n742v
| null |
1427658003
|
1
|
t5_2fwo
| null | null | null |
True
|
CowboyProgrammer
| null |
I see Sudoku solvers everywhere.
Do something more challenging: Create a Sudoku puzzle generator.
| null |
0
|
1317219358
|
False
|
0
|
c2n7xv1
|
t3_ktyc9
| null |
t1_c2n7xv1
|
t3_ktyc9
| null |
1427658007
|
3
|
t5_2fwo
| null | null | null |
True
|
julesjacobs
| null |
Could you point me to the page where they do said comparison?
| null |
0
|
1317219446
|
False
|
0
|
c2n7y89
|
t3_ktg7o
| null |
t1_c2n7y89
|
t1_c2n7s9b
| null |
1427658012
|
1
|
t5_2fwo
| null | null | null |
True
|
axilmar
| null |
No, it is absolutely retarded. It was retarded 15 years ago.
XLib is not retarded at all, it simply doesn't scale well. But it is consistent and orthogonal, unlike Win32.
| null |
0
|
1317219589
|
False
|
0
|
c2n7ytv
|
t3_ktv1z
| null |
t1_c2n7ytv
|
t1_c2n7srl
| null |
1427658020
|
-6
|
t5_2fwo
| null | null | null |
True
|
akoprowski
| null |
Great, good luck! On the 'Learn' tab of the page you'll find resources that should help you get started (and get in touch with us when the going gets tough ;)
| null |
0
|
1317219645
|
False
|
0
|
c2n7z2o
|
t3_kteac
| null |
t1_c2n7z2o
|
t1_c2n7wqz
| null |
1427658023
|
1
|
t5_2fwo
| null | null | null |
True
|
axilmar
| null |
I am not sure why all that is needed. C++ does it better, with less language constructs and less functions.
| null |
0
|
1317219654
|
False
|
0
|
c2n7z49
|
t3_kljc0
| null |
t1_c2n7z49
|
t1_c2n7c2p
| null |
1427658023
|
1
|
t5_2fwo
| null | null | null |
True
|
is_left
| null |
Heh. This is my workplace.
| null |
0
|
1317219700
|
False
|
0
|
c2n7zc5
|
t3_ktxk5
| null |
t1_c2n7zc5
|
t3_ktxk5
| null |
1427658026
|
1
|
t5_2fwo
| null | null | null |
True
|
saplinglearning
| null |
Please send resume and salary requirement to careers@saplinglearning.com.
| null |
0
|
1317219705
|
False
|
0
|
c2n7zcu
|
t3_ku3je
| null |
t1_c2n7zcu
|
t3_ku3je
| null |
1427658027
|
1
|
t5_2fwo
| null | null | null |
True
|
Reorax
| null |
ciw and cw do different things:
cw changes from cursor until end of word
ciw changes the entire word that the cursor is on
| null |
0
|
1317219713
|
False
|
0
|
c2n7zdz
|
t3_ktenx
| null |
t1_c2n7zdz
|
t1_c2n6sfy
| null |
1427658027
|
1
|
t5_2fwo
| null | null | null |
True
|
cockmongler
| null |
I think I'd prefer something like WM_CLEANUP, or possibly WM_MAKEYOURPEACE.
| null |
0
|
1317219729
|
False
|
0
|
c2n7zgi
|
t3_ktv1z
| null |
t1_c2n7zgi
|
t1_c2n7szg
| null |
1427658028
|
4
|
t5_2fwo
| null | null | null |
True
|
dyydvujbxs
| null |
Can we stop upvoting this flamebait troll website, please? It is *The Sun* of software methodology. An inspiring domain name does not make a great website.
| null |
0
|
1317219747
|
False
|
0
|
c2n7zjf
|
t3_ktxk5
| null |
t1_c2n7zjf
|
t3_ktxk5
| null |
1427658029
|
-6
|
t5_2fwo
| null | null | null |
True
|
shimei
| null |
Yes, Racket is good for [developing languages](http://www.hashcollision.org/brainfudge/). Since each program you write is different, it's helpful to have many language [dialects](http://pre.racket-lang.org/docs/html/guide/dialects.html?q=dialect) (e.g. untyped, typed, with lazy evaluation, etc.) to choose from and to be able to whip up your own dialect if you need one. This approach seems to work: the entire [documentation](http://pre.racket-lang.org/docs/html/) is written in the [Scribble dialect](http://pre.racket-lang.org/docs/html/scribble/index.html) of Racket.
| null |
0
|
1317219754
|
False
|
0
|
c2n7zkg
|
t3_kri4f
| null |
t1_c2n7zkg
|
t1_c2n0tzi
| null |
1427658029
|
2
|
t5_2fwo
| null | null | null |
True
|
ISV_Damocles
| null |
1. The API decisions driven by that restriction should have been deprecated years ago. 640K was laughable in the Windows *95* era.
2. You can still read documentation and not figure out that a signal *sent through the operating system specifically involving window management* would not do the expected thing.
3. How big of a change are we talking about here? A single conditional to detect if the code calling the signal function is in kernelspace or userspace, and then act accordingly?
4. And this is a good thing? Why not just give me full access to the computer's memory addresses? I'm a programmer, so I know what I'm doing and certainly won't overwrite other programs' memory, or accidentally write into, say, the Northbridge bus memory addresses. In fact, let me decide when my process gives up control to other processes. Interrupt Requests are just worthless hand-holding.
| null |
0
|
1317219803
|
False
|
0
|
c2n7zso
|
t3_ktv1z
| null |
t1_c2n7zso
|
t1_c2n7wlx
| null |
1427658032
|
-1
|
t5_2fwo
| null | null | null |
True
|
cogman10
| null |
:) Me to (It is where my user name came from). I LOVED DF2.. such a fun game.
| null |
0
|
1317219842
|
False
|
0
|
c2n7zyy
|
t3_ktd67
| null |
t1_c2n7zyy
|
t1_c2n5i3e
| null |
1427658035
|
2
|
t5_2fwo
| null | null | null |
True
|
useful_idiot
| null |
What makes it java gpu programming other than the wrappers around libraries which do all the real work?
| null |
0
|
1317219851
|
False
|
0
|
c2n8003
|
t3_ktwk1
| null |
t1_c2n8003
|
t3_ktwk1
| null |
1427658035
|
6
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317219855
|
False
|
0
|
c2n800v
|
t3_ku203
| null |
t1_c2n800v
|
t3_ku203
| null |
1427658035
|
1
|
t5_2fwo
| null | null | null |
True
|
jrhorn424
| null |
I'd rather order from someone with a lot of positive reviews that say "no problem." But, focusing on one at the exclusion of the other is naive.
The best strategy is to remain skeptical. That means reading each review, discounting the ones that boil down to "no problem" *as well as* the ones that are just pissed off rants. The Internet has no mandatory cool down period before reviewing a product, and I'd venture most people are motivated to post a negative review when they're angry, and less motivated to revise their review if their issue ever gets resolved.
| null |
0
|
1317219870
|
False
|
0
|
c2n803a
|
t3_ktx2g
| null |
t1_c2n803a
|
t1_c2n7q9f
| null |
1427658036
|
9
|
t5_2fwo
| null | null | null |
True
|
a_redditor
| null |
>...which confirms other researchers’ findings that a person feels the most refreshed when awoken during the REM phase.
That's interesting. I've heard of techniques where you try to estimate when the best time to wake up would be based on REM phases, and then set your alarm to the correct time, but if this app works, it could be used to determine the best time to wake up with really great accuracy.
But as lwiczek pointed out, there's literally no information on the technology used. I don't think this belongs in /r/programming at all.
| null |
0
|
1317219922
|
False
|
0
|
c2n80ar
|
t3_ku203
| null |
t1_c2n80ar
|
t3_ku203
| null |
1427658040
|
5
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
i noticed a pattern that i wanted to use a few times, so i made it into a library. it's pretty feature-light at this time, but i'll be adding more to is as i use it more.
the basic idea is that i wanted to use the observer pattern, but i cared what order things were notified in. an example is for capturing mouse input: i want things on layers closer to the viewer to handle input before things on background layers.
things on my list to implement soon:
Where operator
Aggregate operator
SelectPriority (map the priority, rather than the values in the stream)
also, it's still early in development, so if my architecture is stupid, there's still time to change it, if anyone spots something shady. (i wrote it last night/this morning)
| null |
0
|
1317220026
|
False
|
0
|
c2n80pl
|
t3_ku3ph
| null |
t1_c2n80pl
|
t3_ku3ph
| null |
1427658047
|
2
|
t5_2fwo
| null | null | null |
True
|
ISV_Damocles
| null |
Exactly my point. But a simple block of userland applications trying to send signals that can only validly come from the operating system would work just as well. Just call them "receive-only" signals, and state that they are analogous to system calls, but in the opposite direction.
| null |
0
|
1317220040
|
False
|
0
|
c2n80rs
|
t3_ktv1z
| null |
t1_c2n80rs
|
t1_c2n7vg3
| null |
1427658046
|
0
|
t5_2fwo
| null | null | null |
True
|
dyydvujbxs
| null |
This is the best post in this thread, far better than the article.
Scrum launched some of the best software at Amazon, like AWS.
Scrum make good people perform better, by breaking bad habits and forcing communication. Nothing will ever make losers succeed.
| null |
0
|
1317220057
|
False
|
0
|
c2n80v1
|
t3_ktxk5
| null |
t1_c2n80v1
|
t1_c2n7qcp
| null |
1427658047
|
5
|
t5_2fwo
| null | null | null |
True
|
robvas
| null |
It is formatted, and done quite well.
| null |
0
|
1317220087
|
False
|
0
|
c2n80z7
|
t3_ktd67
| null |
t1_c2n80z7
|
t1_c2n4kji
| null |
1427658049
|
2
|
t5_2fwo
| null | null | null |
True
|
cockmongler
| null |
I think a lot of people are getting confused here. WM_DESTROY is an indicative signal, sent as a courtesy by the window manager to let it know a window is about to be destroyed. There is nothing inherently wrong with a userspace application sending it, the receiver can do what it wants with the message.
The confusion it seems comes with windows not having a clear separation between the responsibilities of the window manager, the graphics allocation subsystem and the application. I X11, the equivalent DestroyWindow call in this example would be to send a message to the window manager saying "please destroy that window." This makes it clear who you are talking too. Calling XDestroyWindow tells the graphics layer that you are done with that rectangle of graphics memory (and your window manager will hate you for it, having to detect it and try to clean up for you).
tl;dr; tight coupling between the window manager and the graphics system sucks.
| null |
0
|
1317220175
|
False
|
0
|
c2n81cv
|
t3_ktv1z
| null |
t1_c2n81cv
|
t1_c2n7c3u
| null |
1427658054
|
11
|
t5_2fwo
| null | null | null |
True
|
spif
| null |
How does it detect REM? Facial recognition match against a photo of Michael Stipe?
| null |
0
|
1317220205
|
False
|
0
|
c2n81i6
|
t3_ku203
| null |
t1_c2n81i6
|
t3_ku203
| null |
1427658056
|
62
|
t5_2fwo
| null | null | null |
True
|
pnpbios
| null |
You seem to come from the Wahhabi sect of Linux C++ programmers, so I'm just going to leave this one alone.
| null |
0
|
1317220215
|
False
|
0
|
c2n81ju
|
t3_ktv1z
| null |
t1_c2n81ju
|
t1_c2n7ytv
| null |
1427658056
|
8
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
If you think the documentation is crystal clear, then we have different opinions. IMHO, the blog posting does a much better job of describing how the (poorly named) message works.
> Raymond Chen does not write for MSDN.
Are you saying that blogs.msdn.com has nothing to do with MSDN?
| null |
0
|
1317220216
|
False
|
0
|
c2n81jx
|
t3_ktv1z
| null |
t1_c2n81jx
|
t1_c2n7xaf
| null |
1427658056
|
-4
|
t5_2fwo
| null | null | null |
True
|
hylje
| null |
Widescreen-enabled people who insist to drive their browsers in full-screen mode and decline to enable default CSS to restrict text flow get exactly what they deserve.
The only problem with a culprit is browsers that don't ship with good default CSS for well-formatted pages.
| null |
0
|
1317220251
|
False
|
0
|
c2n81ot
|
t3_ktd67
| null |
t1_c2n81ot
|
t1_c2n5p8a
| null |
1427658058
|
2
|
t5_2fwo
| null | null | null |
True
|
kyz
| null |
>...that overlap the edges of the screen. You'd think it's as simple as it gets but somehow special cases popped up everywhere...
You mean *corner* cases? :)
| null |
0
|
1317220287
|
False
|
0
|
c2n81um
|
t3_ktd67
| null |
t1_c2n81um
|
t1_c2n3g8d
| null |
1427658060
|
7
|
t5_2fwo
| null | null | null |
True
|
robinwholikesjava
| null |
You mean like your own prejudice against JSF 2?
Honestly, have you actually tried using it? It's a very decent framework and anyone who has really used it knows that. A lot of people that don't like JSF have either read a blog from 2004 where some popular guy claimed he didn't like it and have just been repeating that ever since, or have actually tried it in 2004 and somehow think JSF is still exactly like it was back then.
Believe me, just try it. You probably love it! :)
| null |
0
|
1317220295
|
False
|
0
|
c2n81vj
|
t3_kt682
| null |
t1_c2n81vj
|
t1_c2n7u7b
| null |
1427658060
|
4
|
t5_2fwo
| null | null | null |
True
|
Shambot
| null |
and then their mothers come around the corner, and they lick it up.
| null |
0
|
1317220360
|
False
|
0
|
c2n825k
|
t3_ktv1z
| null |
t1_c2n825k
|
t1_c2n6pxu
| null |
1427658064
|
-2
|
t5_2fwo
| null | null | null |
True
|
Amablue
| null |
There are a *huge* number of people who still use 1024x768, not even counting the people on netbooks.
| null |
0
|
1317220444
|
False
|
0
|
c2n82jj
|
t3_ktenx
| null |
t1_c2n82jj
|
t1_c2n6rrw
| null |
1427658069
|
1
|
t5_2fwo
| null | null | null |
True
|
SciK
| null |
In Haskell:
main = mapM_ (putStrLn . flip replicate '*') [1 .. 11]
;]
| null |
0
|
1317220449
|
False
|
0
|
c2n82kf
|
t3_ku2z1
| null |
t1_c2n82kf
|
t3_ku2z1
| null |
1427658069
|
3
|
t5_2fwo
| null | null | null |
True
|
sausagefeet
| null |
I wonder what WM_BALLSDEEP would be for...
| null |
0
|
1317220483
|
False
|
0
|
c2n82pv
|
t3_ktv1z
| null |
t1_c2n82pv
|
t1_c2n7zgi
| null |
1427658071
|
3
|
t5_2fwo
| null | null | null |
True
|
yojoe26
| null |
Great post and I agree with almost everything that you have said. However, what is the reasoning behind positive bullet point #3 - Nothing is added in the middle of a Sprint? If you've underestimated the amount of work involved and developers finish ahead of schedule, why not pull in more stories?
| null |
0
|
1317220523
|
False
|
0
|
c2n82wf
|
t3_ktxk5
| null |
t1_c2n82wf
|
t1_c2n7qcp
| null |
1427658073
|
4
|
t5_2fwo
| null | null | null |
True
|
StrawberryFrog
| null |
> The problem is this: using this process promotes you to offshore raw development as a service, relegates programmers to being "code monkeys", and the people who have no clue how to convert a requirement into coding skim off a lot of the money.
That looks nothing like the agile that I have done, and nothing like any kind of software development (agile or not) that I ever want to do.
Also, Scrum is supposed to empower teams and promote close communications. You can call those buzzwords if you like, but it's the *opposite* of offshore code monkeys. I think you are wrong.
| null |
0
|
1317220529
|
False
|
0
|
c2n82xb
|
t3_ktxk5
| null |
t1_c2n82xb
|
t1_c2n796q
| null |
1427658073
|
8
|
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.