Gotcha: no prefix increment/decrement VB.net operators, but get parsed

In C/C++ and C# one has useful prefix (++index) and postfix (index++) increment operators and corresponding decrement ones.

Although they have a single operant, they’re not working like functions as single + or – prefix would do, but instead they cause side-effects – they edit the variable passed to them. The prefix increment operator first increases a variable’s value, then returns it as result, while the postfix one first returns a variable’s value, then increases it.

Visual Basic.net doesn’t have such operators (and they don’t seem to plan to add such from their response on related feedback at Microsoft Connect.

However, if you type-in

Dim x = ++y

the compiler won’t complain. In fact, it won’t complain even if you type

Dim x = +++++y

The reason is because it thinks this last crazy-looking expression is:

Dim x = +(+(+(+(+y))))

Similarly, it accepts expressions like

Dim x = –y

and

Dim x = —–y

So a programmer coming from C# or converting C# code to VB.net has to be extra careful when converting ++index expressions to use their own implementation as a function that takes a ByRef parameter

LvS (Learning via Subtitling) opensource VB.NET application for FLL learning

The LvS application for Foreign Language Learning (FLL) via Film Sutitling that I co-designed and originally authored in Visual Basic.net 2005 (latest version was compiled on VB.net 2008) for Hellenic Open University in the context of EU-funded research project LeViS, is opensourced at CodePlex (Microsoft’s community site for opensource projects):

http://www.codeplex.com/LvS

Project Description

Learning via Subtitling: Software & Processes for Developing Language Learning Material based on Film Subtitling (http://levis.cti.gr)

The main focus of Learning Via Subtitling is the development of educational material for active foreign language learning based on film subtitling. It aims to cover the exigency for active learning where cultural elements are involved effectively through real-life (simulated) activities and the need for productive use of multimedia not as nice add-on but as the core of an activity. LvS is a software environment designed and implemented to serve the pedagogical needs of the LeViS project.

Funding framework: Socrates Programme, LINGUA 2 (Development of Language Tools and Materials), European Commission, DG for Education and Culture

Coordinating Institution: Hellenic Open University (HOU), http://www.eap.gr

Description of the LvS Environment

The LvS environment
Learning via Subtitling (LvS) is a subtitling simulator designed for educational activities’ purposes. This software tool can be used by language teachers to create activities based on subtitling film-scenes, news, documentaries etc., and by FL learners to carry out these activities.

It comprises four basic areas – Multimedia player, Document viewer, Subtitle editor and Notes – as shown in the screenshot below.

Screenshot of an LvS learning activity

Multimedia player area
It allows the learner to view, rewind and forward the film, both with and without subtitles.

Document viewer area
It allows the learner to view the instructions and other files necessary for the activity (information about the clip, the script, exercises, etc.)

Subtitle editor area
It allows the learner to edit and manage the subtitles. Each subtitle line is divided in four columns where the subtitle’s data is viewed: Start time and End time (the temporal points in the clip when the subtitle text appears and disappears from the screen), Duration, and Subtitle text. The next two columns are for teacher and learner comments. The teacher can mark the subtitle line with an icon (“well done”, “warning” etc.) which when clicked takes the learners to the Notes area where they can read the teacher’s comment.

Moreover, an algorithm calculates the number of characters introduced in each subtitle: if it exceeds the time and space constraints, the text is marked. This does not affect the appearance of the subtitle on the multimedia player and the subtitle file can still be used and saved.

Also, if the number of the subtitle (first column) is double-clicked, the “current time” of the clip is moved to the equivalent time-point, enabling the learner to view and listen only the fragment where the selected subtitle appears.

The users can create new subtitles in the subtitle file by clicking on the buttons “Start subrtitle” and “End subtitle” in order to establish the time when they want the subtitle to appear and disappear respectively. This process is called “cueing”. Whether the cueing is performed by the learner or the teacher depends on the design and the objectives of the activity. If the teacher aims to reduce the technicalities of subtitling, s/he may provide the in and out times of the subtitles together with the rest of the activity elements. On the other hand, if the objective is for the students to practice listening, this process may be carried out the students: in order for them to find when exactly a new subtitle should appear, they are obliged to listen to the clip over and over again in order to insert the in and out times correctly.

Notes area
It allows the learner and the teacher to exchange feedback. It is divided in the general notes and the comments per subtitle. When a comment per subtitle is clicked, the “current time” of the clip is moved to the moment when the respective subtitle appears.

Other Software Features:

• Authoring mode (see Glossary in this tutorial)
• Importing (Packed activity, Video, Subtitles, Documents)
• Exporting (Packed activity with or without video, Subtitles, Documents)
• Student and Teacher general Notes and per subtitle Comments
• Multiple Documents in different tabs available
• Auto-resizing parts of the interface
• Option to write subtitle text directly under the player with simultaneous update of the subtitle grid
• Most recently used files list
• Buttons “Set subtitle start” and “Set subtitle end” modifying the Start time and End time of an existing subtitle

The files needed for the creation of an activity (input files) are:

a) a multimedia file: eg. a film scene, a video-clip, a documentary.
b) one or more documents: e.g. a powepoint presentation with the instructions, an MS Word document with an exercise.
c) a subtitle file – unless the activity requires the students to create their own subtitles.

LvS runs under Windows 2000, Windows XP, Windows Vista and Windows 7 (should run ok on Windows Server 2003 and 2008 too I guess)

start/kill processes with VB.net

a friend was just asking me over MSN messenger how to start and kill processes using VB.net, so here is some info on it:

 

* to start a process you can just do

 Process.Start("test.exe")

or

 Dim proc As New ProcessStartInfo()

 proc.Filename = "test.exe"

 Process.Start(proc)

 

see 

http://msdn2.microsoft.com/en-us/library/system.diagnostics.processstartinfo.aspx

 

* to kill a process you can do something like (haven’t tried it though):

 

Dim plist As Process() = Process.GetProcesses()

For Each p As Process in plist

 Try

  If p.MainModule.ModuleName.ToUpper() ="TEST.EXE" Then p.Kill()

 Catch

  ‘seems listing modules for some processes fails, so better ignore any exceptions here

 End Try

Next p

 

see

http://msdn2.microsoft.com/en-us/library/system.diagnostics.process.kill.aspx

+=1, -=1 not atomic operations at VB.net

This is something that bit me sometime ago: seems +=1 and -=1 aren’t atomic operations at VB.net and other .NET languages (not sure for C++) although modern CPUs have INC and DEC instructions at least for integers (maybe IL – intermediate language [for .NET compilers’ target "theoretical" machine spec] – doesn’t define such?)

 

You have to use the class System.Threading.Interlocked and specifically the Increment and Decrement methods it has (you can pass an integer ByRef to them for example to do say i+=1 and i-=1 in a thread-safe way). That class also has methods to Add/Subtract more than 1 (haven’t checked if it also support multiplications/divisions etc.)

 

Many thanks to the guy who tiped me about this at a Microsoft Hellas presentation some years ago in Athens, wouldn’t have spotted that class myself, although I was already skeptical whether +=1 and -=1 were atomic operations (thread-safe, fetch and update done in 1 step) in VB.net and other .NET languages or not and was querying about it some MS Hellas people (who didn’t know either – I even asked J# program manager sometime ago and they had to doublecheck to be totally sure it didn’t do it as atomic operation either)

 

I wonder about what C++ compiler does on .NET regarding this one, I though the ANSI C++ spec said += and -= are atomic, but I might be remembering wrong