The Big Programming Thread - Page 579

On February 06 2015 07:02 obesechicken13 wrote:
Setting:
I had an interview question yesterday in C#, for .net

The guy asked me to fill in pseudocode for a login.

My Answer:
I just verified the password, then you had to make an update and an insert. At first I didn't get what was so special about the question, but he hinted that maybe one of the queries would fail. So like with a banking transfer, you'd want to make sure either both queries (withdrawl from your account, deposit to another account) worked or that neither did.
How would I handle that?

I eventually answered rollbacks, but I had never used transactions with sql querieis so I didn't mention anything about transactions but he still seemed to be like "alright, at least he knows to use rollbacks".

Is there a better way?
Do you need try catch exception handling or is there a better way to check if queries don't work properly?

The database type would be MSSQL but I doubt it'd matter.

On February 06 2015 07:15 bangsholt wrote:
First query... Well, that's binary, in the sense that you're comparing a username and a hash to a username and a hash. If that fails, you don't log the user in.

Second and third query you wrap in a transaction, which you would do with the SqlTransaction class in C# + MSSQL - then when you commit - i.e. you've reached the point where you want to know if everything is consistent or not, then you do a try catch on that - and if the commits fails, you rollback and tell the user it didn't go as expected.

A transaction cannot be rolled back after a COMMIT TRANSACTION statement is executed, except when the COMMIT TRANSACTION is associated with a nested transaction that is contained within the transaction being rolled back. In this instance, the nested transaction will also be rolled back, even if you have issued a COMMIT TRANSACTION for it.

On February 06 2015 07:23 darkness wrote:


This property is called "atomicity" and is part of ACID: http://en.wikipedia.org/wiki/ACID#Atomicity

Here is a good example: https://msdn.microsoft.com/en-us/library/system.data.sqlclient.sqltransaction.commit(v=vs.110).aspx

You commit a transaction when no error occurs

On February 06 2015 07:25 obesechicken13 wrote:

Thanks.

Followup question:

https://msdn.microsoft.com/en-us/library/ms181299.aspx

I understand there's all this theory as to what changes can be rolled back based on atomicity.
But why does microsoft say that the rollback can't be done if the commit is executed? Does a failed commit not execute?

Durability
Main article: Durability (database systems)

Durability means that once a transaction has been committed, it will remain so, even in the event of power loss, crashes, or errors. In a relational database, for instance, once a group of SQL statements execute, the results need to be stored permanently (even if the database crashes immediately thereafter). To defend against power loss, transactions (or their effects) must be recorded in a non-volatile memory.

On February 06 2015 05:59 spinesheath wrote:

Performance optimizations like that not only don't matter, they are outright bad unless you profiled your application's performance and determined that doing these things actually improves your performance significantly. Hint: typically you'll find some awful algorithm that hogs all the processing power and can't be improved by more than .00001% by using an xor instead of an assignment.

In the case of ++i over i++ it's just a straight up potential improvement with no downsides unless you specifically need the semantics of i++. Both are equally readable.
Whether you should use either of them is another question, but if you use one of them, use ++i.

Performance optimizations at instuction level will usually be done by a moderately intelligent comiler anyways, no need to bother with them.


Let me be clear: Do not attempt to optimize your code for performance unless you actually have a performance problem AND profiled it.

On February 06 2015 05:09 RoyGBiv_13 wrote:
[...]

Many people use f.lux to dim the screen after sundown, which is an option for helping to avoid high energy light. It takes about an hour after seeing a moderately bright blue or purple light to fully adjust back to clear night vision, so avoid doing anything that requires eyesight immediately after computer usage, such as driving.

On February 06 2015 07:23 darkness wrote:


This property is called "atomicity" and is part of ACID: http://en.wikipedia.org/wiki/ACID#Atomicity

Here is a good example: https://msdn.microsoft.com/en-us/library/system.data.sqlclient.sqltransaction.commit(v=vs.110).aspx

You commit a transaction when no error occurs.

private void BlahSomething()
{
  using(TransactionScope scope = TransactionUtils.CreateTransactionScope())
  {
    // do database work, maybe use entity framework
    scope.Complete();
  }
}

On February 06 2015 22:45 Artesimo wrote:
Wooow nailed my programming exam, most likely a 1.0 incoming. Thanks to all you kind people that helped me with my newbie-questions.

On February 06 2015 22:45 Artesimo wrote:I bet he is "verbeamtet"(which means its effectively impossible to fire him)

On February 07 2015 01:07 obesechicken13 wrote:
Happy Korean birthday darkness

On February 07 2015 02:42 Zocat wrote:


Congrats to that.

Lauftext/Laufschrift is a word you should know as a German. A ticker is something different. A ticker can be implemented as a Lauftext, but it can also just update as a whole. Think Bundesliga-Ticker, where you can always read the whole match and nothing is scrolling.
Overall you should be able to clarify such definitions during an exam.

And if he discussed it in one of his lectures, yes he did try to set you up. For passing.
If it's on a slide it can be part of the exam, if a whole lecture is spent on it, it _will_ be in the exam.
"a lot got burned by it, especially those who wherent in that exact lecture." If people are not in the lecture / don't bother to learn the missed stuff, then it's their fault, not the professor's one.

You have the freedom to miss lectures, you have the responsibility to still know the material.