I need a way of flexible defining the order certain tasks are performed. There is no parallelism, only one task is active at a time. Every task has an outcome (a set of primitive values, like Integers Floating points or Strings. Which task is performed next can depend on the outcome of previous tasks.
Most of the time these dependencies are simple, like "outcome > 5". But sometimes they are more complex. For example a certain task is performed next, if a certain word occurs multiple times in the String-output of a previous task. They can also be more complex conditions in ways I do not think of yet.
So my Idea is to use a simple scripting language to define the flow/order of tasks. Than it can look like this:
outcome1 = performTask('task1');
outcome2 = performTask('task2');
if (outcame1.value > 3 && outcome2.value == "success) {
performTask('task3');
} else {
performTask('task4');
}
I like the Idea. Now the questions raises which scripting language to use?
Since the end user will write the scripts and possibly exchange scripts with other users, I am worried about "viruses". The outcome data is highly confidential so there must not be a way to somehow output the data. Ideally I would limit the usage of the language to the core functionality (assuming this does not involve any IO) plus a set of functions I provide.
At first I will use the language in a C++ project, but it would be nice if the browser (javascript) could be supported in the future.
I could invent my own scripting language and write my own interpreter, but that would be much work I am hoping to avoid.
So which scripting language with which interpreter could I use to meet this requirements?
What one usually does for this is "sandboxing" For example lua can be sandboxed, which is described here.
I'm wondering, when is it appropriate to use conditional operators?
I've found I can use them an awful lot, and it really shortens the number of lines in my project but I worry that it makes my code harder to read for people I work with.
I know there's quite a few coding standard formats that people stick to and I was wondering if they made any mention of the use of conditional operators.
(a == b) ? true : false;
For the sake of Googling, you should know that this is often called the ternary operator.
Myself, I like them when they are short
var quantity_message = qty > 7 ? "enough" : "insufficient";
But I think they get hard to read very quickly as they get longer.
The common conventions such as the official Java conventions or Google's java conventions do not talk about whether to use ternary expressions, but have some comments on how to format them. I don't think anyone would ban them outright, but I'd be judicious.
The isValid function doesn't support this capability as far as I can tell, and there is no built-in "isUDF" or "isFunction" function. So far, the best I've been able to come up with is
findNoCase("func", myUDF.getClass.getSimpleName()) neq 0
When used on a UDF, the Java method getClass().getSimpleName() always seems to return a value with the substring func in it. I know very little about Java, though, so I have no idea how reliable this is.
Is there a better way to identify a reference to a function?
isCustomFunction() or isClosure(). CFML should not require two functions here, but due to - I suspect - poor understanding of the concept of closure on the part of the Adobe ColdFusion team, they kinda messed this up. Commentary on this: "Am I right to think this is stupid?"
I'm a seasoned programmer and therefore feel a little embarrassed asking this question but decided to do so anyways.
I'm reading this book, and have also seen various examples across the net where the order of arguments in a compare operation is reversed and I wonder if there is a reason for it, or just because it looks "cool" and does the exact same thing.
Example:
I would code:
if(bool_variable == YES)
while I saw in this book and in various examples
if(YES == bool_variable)
Explanations?
Thanks a ton!
Some people like yoda conditions because they can help you find errors where you accidentally type = instead of ==. For example:
if (var = YES)
will compile but probably not work the way you want it to. Writing it the other way around:
if (YES = var)
will cause a compile-time error. I personally dislike this construct, but to each his own, I guess.
Carl's got it -- a programmer who puts a constant on the left side will be protected by the compiler.
I just wanted to add that perhaps one of the reasons people switch them around is that one or one's employer may have code style guidelines that specify which side the constant should be on, but of course this just lends itself to the safety net of syntax errors.
I personally have always put the constant on the ride hand side for readability, but to each his/her own.
Do languages become more verbose as they mature? It feels like each new version of VB.net gains more syntax. Is it possible to trim down some fat like the keyword "Dim"? C# also feels like it is getting more syntax since version 1.
C# has certainly gained more syntax, but in a way which makes it less verbose.
Virtually every feature in C# 3.0 allows you to do more with less code.
That's the VB idiom. All languages have an idiom, and there are plenty that go for verbose and spelled-out. Thank your lucky stars you're not WRITING IN COBOL.
C# evolved out of the C-like languages, and in the C tradition brevity and terseness are valued, hence braces, && and ||, int not integer, case-sensitive lower-cased code. In the VB idiom, long self-explanatory keywords are good, terse keywords or cryptic symbols are bad, hence MustInherit, Dim blah as Integer and case insensitivity but with a tendency to Capitalise Your Keywords. Basically, stick with the idiom of the language you're using. If you use (or have to use) VB, then get used to the verbosity - it's intentional.
There's nothing wrong with verbosity, in fact it often can be a very good thing.
I assume you have meaningful variable names? Descriptive method names? Then why is there a problem with typing 'end if' instead of '}'. Its really not an issue at all, if anything, the terseness of C# is more of a problem trying to fit as much as possible into as few characters as possible - that means it harder to read, not easier.
Okay... this feels embarrassing to admit, but I like the use of Dim in VB.NET. Yes, it's not serving any particular use that couldn't be inferred by the use of "As" later... but to me, there's something absolutely "beat you over the head" obvious about having declaration statements start with Dim. It means when someone's looking through the code, they don't even have to think about what those statements mean, even for a microsecond. Languages like C# have declarations that are obvious enough, but if you're just browsing by it you may have to consider it for a moment (even the most brief of moments).
There's something "extra obvious" about having a special keyword at the start of certain kinds of statements. In VB.NET, assignments start with "Dim" and calls to methods (can) start with "Call", giving them a kind of "left side uniformity" that If, For, and other constructs already have: you get the barest gist of what's going on with that line just by looking at the very start of it. Using these almost gives you the equivalent of a left-hand column that you can browse down extremely quickly and get the gist of what's going on on some kind of basic level ("Okay, we're declaring things here... we're calling to other things here...").
That might seem irrational or even silly to some people... but it does make the purpose of each statement explicit enough that it feels faster (at least to me) to browse through... especially when browsing through unfamiliar code written by others.
I guess, in the end, it comes down to "different strokes for different folks". I don't mind typing the extra three characters for that obviousness of purpose.
VB.NET is great as it is, it brings more clarity in code.
For instance I love the fact how you can describe what your ending.
End while vs }
End for vs }
End if vs }
And really the verbosity isn't an issue while typing because of intellisence.
Verbosity and readability often go hand-in-hand. Lately I've come to fear the word "Elegant", because it generally translates into "Fun but less immediately readable"
Of course the person writing the code always says "Well it's MORE readable to me because it's shorter/more elegant.
that's crap. It's always easier to read something more explicit unless you have so much trouble reading that it takes you two hours to get through a Dick and Jane novel.
Note that I'm not talking about redundancies, just being explicit and spelling out your desires.
As a programmer it's much MUCH more fun to write elegant expressions, but I've found myself looking at the "elegance" of others and even my own "elegance" after a while and I'll change it to something more explicit, readable and reliable when I realize that although it was fun to write, I just spent more time reading/debugging it than it took to write in the first place.
On the other hand, DIM is just stupid :)
I'm slightly out of my depth here.
I like what everyone calls verbose. Does no one ever wonder my we don't have multiple nested parenthesis in any natural languages (e.g. English)? In fact nested parenthesis really need the convention of indentation to make then legible at all. In natural languages we use verbose clauses and multiple sentences, to avoid, or at least explain layering parenthesis.
Also in a certain sense I wouldn't say vb has much more syntax than c# at all. It doesn't really have many more lexical tokens in a certain block of code than would c# (Does it?). It has about the same syntax as c# it just has longer syntactical tokens, 'End Sub' instead of '}' for example. For most pieces of syntactical plumbing, the VB version will just be more typing (if you are sworn off intelisense), Also '}' is ambiguous compared to 'End Sub' since it also means 'End If' and whole load of other things. This doesn't make it more concise in a certain sense, There are still the same number of tokens in the code, but from a smaller subset of more curt token markers. But different tokens in C# have different meanings depending on the context, which requires you still to have that nested level in your mind as you read the code, in order to get, for example what kind of code block you are reading if you lose your place, even though the end of the code block could be in view you might have to look up to see the beginning of the code block. Even where this is not the case is && really better than AndAlso?
Dim I suppose is quite useless, an extra lexical token compared to c#, but I suppose at least it's consistent with linq, vb doesn't need the var command. I can't think of any other candidates for the chop. Maybe I don't have the imagination.
I'm sure someone is going to come along and tell me how wrong I am :) My best guess this is to do with personal preference anyway.
Then C# should get rid of ";" at the end of every fricking line :)
Default should be easy way to go such "New Line" instead of a ";" if you want exceptions such 2 statements in the same line then you need use a separator such as ":" or ";"
Some people like that. I suspect things like Dim are left in for legacy reasons as much as anything else.
VB does have some nice short cuts though. For example the conversion routines. Eg CInt, CStr etc
OK I'm an old C programmer that came to .Net via C#, and Now I'm working in VB.Net
I have to say at first I was appalled by the verbosity, but having gone back to
C# for I bit, I have to admit I like VB.Net a bit more now.
I can write VB code that reads better and is less cryptic and it really doesn't take
up much more space (especially if you put all your C# curly braces on their own line)
Also the editor in Visual Studio takes care of most of the verbosity for me.
I like how Dim X As List(Of SomeType) reads as opposed to List<sometype> X
Semi-colons are a nuisance now. Curly braces are annoying.
I do miss the square brackets for array refs, a little bit though.
Ever since I saw this...
lowercase keywords?
...I've been hoping it would get included in the language. It's amazing how much more readable it is Without All The Capitalized Keywords.
C# is not a user-friendly language and takes many MORE lines of code to accomplish the same task as VB.Net. Optional parameters, with/end with, etc. are not supported within C#. Even db connections take more code in C#. Star Wars fans love the C# though, as you get to talk like Yoda while you're programming.
My $0.02: VB.Net's intellisense features, shortcuts, logical readability, etc. make it a superior language.
Yes I know what you mean, it can get a bit long winded, I find it becomes hard to read due to there being to too many keywords and making it hard to see the logic behind it all but hey some people like it.
I have just recently started writing all my stuff in C# and I must say I have come to like it a lot more since I just cut of VB and said right C# from now on, so if you are that worried your could always just switch.
Use a pre-processor... and loose any hope to be read by anybody else (or yourself in some years, perhaps...).
I will answer what is often answered to people complaining that Lua is verbose: if you want a concise language, you know where to find it. There are tons of languages around, even if you restrict yourself to the CLR, so why complain about the one you chose? (I know, you might work on a project you didn't started, etc.).
That's not a flame or something. There are many languages for a reason. Some like them super-concise, close of mathematical notations, others like them (more or less) verbose, finding that more readable. There are languages for all tastes!
for one thing that i don't like about VB is this
print("ByVal sender as object, ByVal e as EventArgs");
vs C#
object sender, Eventargs e
Doing so will only make your code harder to read.