I'm curious how this is off topic. If the flagger could please explain his logic and possibly enlighten me as to where I've gone wrong, I'd be grateful. — DanteTheEgregore11 hours ago
SE sites don't want to enlighten askers, it wants to get rid of them
@JourneymanGeek Seriously, though. The ratio of "close with a nice explanation of what's wrong" to "close and burninate to hell" is somewhat... skewed on SE.
So apparently proper way to write programs and class libraries in C# is to make every class and method public and name them all with 3-9 apparently random letters followed by "set".
MUMPS (Massachusetts General Hospital Utility Multi-Programming System, later: 'Multi-User Multi-Programming System') or alternatively M, is a general-purpose computer programming language that provides ACID (Atomic, Consistent, Isolated, and Durable) transaction processing. Its most unique and differentiating feature is its "built-in" database, enabling high-level access to disk storage using simple symbolic program variables (subscripted arrays), similar to the variables used by most languages to access main memory.
The M database is a key-value database engine optimized for high-thro...
GREPTHIS()
NEW SET,NEW,THEN,IF,KILL,QUIT SET IF="KILL",SET="11",KILL="l1",QUIT="RETURN",THEN="KILL"
IF IF=THEN DO THEN
QUIT:$QUIT QUIT QUIT ; (quit)
THEN IF IF,SET&KILL SET SET=SET+KILL QUIT
// The constructor of the class is private, so nobody can instantiate it. // Because the class provides static methods only there is no need to do // that.
@DanteTheEgregore that seems kind of obvious, so the only WTF is that they had to put that in as a comment instead of assuming the user/maintainer would know that
> A private constructor is a special instance constructor. It is generally used in classes that contain static members only. If a class has one or more private constructors and no public constructors, other classes (except nested classes) cannot create instances of this class. For example:
We are using "VB .Net" programs installed in server which is running Windows server 2003 R2. We can rename ".Net" exe files in server even if those files kept open in client PCs which are running on Win XP and Win8.
But when the program is kept open in Win7 PC, we are not able to rename the exe o...
TL;DR (and rewritten in English): I have an outdated Windows Server OS pushing CIFS/SMB, and oddly enough, clients running XP or Windows 8 are unable to lock files on the server, but Windows 7 clients can (O.o?)
At my first workplace we were using Digital Standard MUMPS on a PDP 11-clone (TPA 440), then we've switched to Micronetics Standard MUMPS running on a Hewlett-Packard machine, HP-UX 9, around early 90's.
Is still MUMPS alive? Are there anyone using it? If yes, please write some words about it: a...
maybe putting him in mindjail made him so mad that he broke RSA using functional programming (because FP solves every problem) and got into my server by deriving my keypair, then disabled Cavil
It goes by a different name now, but it's totally backwards compatible with everything old, one of the fellows who hangs about Programmers still does it
I don't know how he tolerates it, he's been a senior .NET dev in the past but just can get good paying gigs in MUMPS because it's so rare and he's good at it
it's not that hard to understand: old guy knows dying tech that a lot of orgs still depend on; demands high salary; gets to be complacent, use stuff he knows and is familiar with, and get paid more than his peers
@allquixotic He's not an old guy actually, he just randomly got a MUMPS gig fresh from college and it's kind of been somethign that's followed him around even as he's worked in other techs
MUMPS is very much alive. It has been one of the most trust-worthy systems going in the proper hands. The programming staff is usually small and the up-time is impressive. It may seem to the uninitiated that MUMPS is obtuse, but it is possible to write very lucid and highly functional code in ...
also he might have accrued huge lists of regexes and automation macros (in AHK or whatever) and other stuff to help him quickly deal with the worst pains of MUMPS, depending on how sophisticated he is
I have a few trinkets that I use to deal with the realities of VBScript
@allquixotic He actually learned Haskell recently after following some link I passed around, and ever since he's been talking about writing a pre-compiler in Haskell
This is some MUMPS i wrote for fun. I guess if you can analyze this, your tool works:
Q N R,Q,C,D,E,W,B,G,H,S,T,U,V,F,L,P,N,J,A S N=$G(N),Q='N,F=Q+Q,P=F+F,W=$L($T(Q))
S W=$E(W,Q),S='N_+N,W=W-F*S,L=$G(L),R=$C(Q_F_P),R(F)=$C(F+Q_F),R(P)=$C(W-F) W #
S T=$E($T(Q+F),F,W\S)_$C(W+S+F) X T S B=$P(T,$C...
Last conversation I think his design was just to put some jargon blocks to say like OTHER_LANGUAGE_STARTS_HERE blablabla OTHER_LANGUAGE_ENDS_HERE and have precompiler parse and macro expand it into MUMPS
well if you're going through all the effort to do that, you might as well just write some sort of translator (I guess you could call it a compiler) that accepts your favorite language as input, and spits out MUMPS as output
compilers whose task is to take some language and transform it into some other high-level language are becoming increasingly common; the idea of a compiler spitting out some bytecode or native machine code is a bit too restrictive for the modern compiler guru
the thing that strikes me about MUMPS and VBScript and other such environments is that veteran developers in these languages really tend not to mind them, on the whole; and once they've accumulated a critical mass of tricks and code snippets, they don't really miss what the language lacks, because they're so capable of getting shit done
if you are in such an environment and you hate it, either you haven't done it long enough, or you're one of those code poets who isn't satisfied unless your code is bloody elegant
@JimmyHoffa except where the runtime environment itself provides ridiculous restrictions (as in the case of VBScript), I'm not sure that quality directly follows from what the language offers
@allquixotic There are 2 products on DreamSpark: "Microsoft Windows 8.1 Symbols" and "Microsoft Windows 8.1 Symbols Debug Checked". Both show up on the Windows 8 product, not on Visual Studio.
My DreamSpark account shows me several download links for Windows 8. I am not sure what is the difference between them and which one is suitable for me.
Microsoft Windows 8 with Apps 32-bit
Microsoft Windows 8 with Apps 64-bit
Microsoft Windows 8 Debug/Checked Build 32-bit
Microsoft Windows 8 D...
I'd suggest a combination of projectile + ctags + ECB (or just CEDET) + cscope.
Projectile offers easy navigation in a project's files and some nice functions like text search, tags regenerations, etc. ECB is an Emacs Code Browser that makes Emacs appear more IDE-like, CEDET will give you smart ...
@JimmyHoffa but if the strategy and visitor patterns work, and they don't introduce bugs, what's the point? we may just have a difference of philosophy here, but I'm very much of the opinion that a language+environment pair is best judged based on the results it produces, where "results" is an amalgam of both the good and bad stuff (bug/defect rate, performance, compatibility, etc)
for me it just comes down to gathering data on this stuff and making an empirical conclusion after observing a few big software projects being written, and then figuring out what the best result-set is... whichever one comes out on top, wins
heck, if Haskell happens to have the best result-set, so be it; if that were the case, I'd proudly declare it the best language/environment
and then there are people who have already gathered this data and knowingly use something that's worse, like VBScript :-) that's just disappointing, but eh, they're still getting shit done... just not getting it done well :/
@allquixotic The point is that they do introduce bugs by way of code overhead and maintenance overhead compared to when a language supports them at the language level and you have a code reduction, plus with language level support you can get additional guarantees like atomicity for multithreading or other things which are much harder to get right done manually by a programmer each and every time
@Bob That may be a side effect of someone misusing features but more features rarely means the resulting code is more complex if the code writer is wise enough not to write overly complex code
@Bob mono has a lot of people working on it still, so don't count them out
I'm still waiting for their second-generation garbage collector to stop leaking and pegging the CPU with OpenSimulator, but they're definitely working on it
running Mono <= the latest stable is really foolish because their velocity has been good in recent months, so you're missing out on a lot if you use older mono
actually there are an incredible number of LLVM and JIT-related commits in mono master just the past week or so; I might try mono git master on OpenSimulator with sgen and llvm enabled to see if it's any better
@Bob hm, if they can't get those methods to work correctly they might want to mark them with some kind of attribute or warning
it really isn't a stretch to say that you have to specifically test your code with Mono to get it working well; you can't just take any old .NET program and run it on Mono without any worries
but then again, there are plenty of libraries and programs out there that do test on Mono, and make sure that their released binaries work on both .NET and Mono
it gets super complicated if you leave the safe world of Windows though because Mono supports a great many platforms
and it can't properly hide all the platform differences seamlessly from the developer
there is less platform abstraction in Mono than, say, Java, in my experience
also, WinForms applications look ugly in Mono... especially on Linux
MUMPS is very much alive. It has been one of the most trust-worthy systems going in the proper hands. The programming staff is usually small and the up-time is impressive. It may seem to the uninitiated that MUMPS is obtuse, but it is possible to write very lucid and highly functional code in ...
This is some MUMPS i wrote for fun. I guess if you can analyze this, your tool works:
Q N R,Q,C,D,E,W,B,G,H,S,T,U,V,F,L,P,N,J,A S N=$G(N),Q='N,F=Q+Q,P=F+F,W=$L($T(Q))
S W=$E(W,Q),S='N_+N,W=W-F*S,L=$G(L),R=$C(Q_F_P),R(F)=$C(F+Q_F),R(P)=$C(W-F) W #
S T=$E($T(Q+F),F,W\S)_$C(W+S+F) X T S B=$P(T,$C...
