Detail Plan of LAB organized by BIT01 -2011

Everyone: Please leave a comment with appropriate reasoning if you think some of the parts of the should be altered or skipped or something more should be added.

BIT01: Reply this topic to let everyone know which topic you want to cover. Please do not hesitate if someone else has already taken your choice. We will discuss together to resolve conflicts.


The complete plan is not fixed because the language is not selected yet. However, most of the course will NOT be language specific. Here is a rough of the language independent beginning.

1. The Object Oriented Concepts
   
   
   
   1. Class and Object
   
   
   2. Namespace
   
   
   3. PIE: Encapsulation
   
   
   4. PIE: Inheritance
   
   
   5. PIE: Polymorphism
   
   
   6. SOLID: Single Responsibility Principal
   
   
   
   

1.1 is almost obvious.
I considered 1.1 and 1.2 to be covered in one lecture. To end the first lecture with something easy-to-understand, I have chosen Namespace to be the second topic. If we do not consider it to be a good reason, I think namespace can be placed almost anywhere inside section 1.
Then comes PIE. It should be placed after Class and Object, however, there can be question about their internal ordering. Encapsulation is first because of its importance over the others. Polymorphism is the last because Dynamic Polymorphism depends on Inheritance.

The biggest question I am expecting is about Single Responsibility Principal. I believe this must be covered in the course, question may be about the time. Should it be immediately after PIE? I am not sure.
Now, why I think SRP must be covered: despite of its importance in good OO design, I have seen many people dangerously violating this principal. A design violating SRP may cause very potential damage to its manageability. I think the concept should be made clear to the students from very beginning.
PIE and SRP should be covered in two lectures.


Alim told that he wants to cover PIE.
I am interested about Class and Object., also Namespace.
Anyone wants to take SRP?

looks pretty good to me. But I am uncertain about one thing.
How will we sync with each other? What I mean is..
One of us will lecture a class for.. two hours. If the next one wants to continue from where the previous one stopped, he needs to know details about it. How much was covered exactly? Was it enough to continue the topic he was supposed to continue? How will we ensure that? Also comes the issue of syncing with the teachers!

A good way can be teaching with the assistance of slides. In that case, the next student lecturer can at least gain some idea about what his previous one lectured about at class, even if he was absent! (which is likely, due to Sunday-Saturday Issues)

I do not see the plans regarding the participation of students in this plan. I mean, this is a lab course, right? If we lecture them all around, what will they do, other then listening? I understand that you didn't specify them because of the language issue, but I consider learning OOP in this way.

It is like reading theories about the taste of a food which you never tasted! The best way to explain is to make them eat that food first

Even if we try to explain the theories, code snippets should be essential.
I think you will agree with me at least on the last point Mohaimin, if you think from a beginner's level.

About the first course details, looks pretty good.
But are you sure that PIE is going to take only one lecture? I mean, just like SRP, many are not even sure about various things of PIE. Remember the classes of Maeenul Sir?

About student lecturers, is it possible to allocate multiple lectures in one lecture? I am considering this on the basis of lab works, because it is generally hard to give full attention to every single student for a single student lecturer in a lab work. I would go to the extent of saying that allocating multiple lecturers per lecture might be a good idea as well, considering that they will be able to fill one other's lacking.

But are you sure that PIE is going to take only one lecture? I mean, just like SRP, many are not even sure about various things of PIE. Remember the classes of Maeenul Sir?

One thing I had in mind but missed in the post. The first lecture is 2 hours for sure. But I assumed at least 3 hours for the next ones (Saturday Morning).
Also, I told that 1.3 to 1.6 two lectures together. I was not planning for very detail about SRP, only the basic idea. In that case, PIE getss more than one and half lectures. That means more than 4.5 hours. Still, I agree with you that it may be too little time for PIE. So may be we should extend the time to two complete lectures.
In case we do not have 3 hours time for each lecture. We should allocate 1 full lecture for each part of PIE. Do you agree with this?


About the synchroniazation issue. That is obviously a big thing to conssider. The slide idea seems effective. We should prepare slides at least with the topic headings.
Another way can be creating a topic in the forum where the we will post the topic titles we covered in a class.
This is not possible to strictly maintain the time line because neither we nor the listeners are Robots. So, if someone things that the lecture is incomplete, s/he should continue the lecture on the next day.
I have no idea how to synchronise with the teachers. We should discuss with them about this.

If we lecture them all around, what will they do, other then listening?........
Even if we try to explain the theories, code snippets should be essential.
I think you will agree with me at least on the last point Mohaimin, if you think from a beginner's level.

Yes I agree. Until inheritance, C# and Java syntaxes are all the same. So, displaying some codes will not be a problem. But the problem will arrise when they will run the programs themselves. So, we should discuss with course teacher (Kabir Sir) ASAP.
We must plan such a way that they have to type a lot of codes by themselves. How to acheve that is up to individuals of us. We should plan well before delivering a lecture.

I think, SRP should not be included. First let them violate the principal, let them do some bad codes, then let them know its a bad idea, so that they can get a strong reason. But as very first, if you let them know its a bad idea, may be they will not get the point why this is bad to violate SRP.

I agree with Rokon.We should teach them "how to use inherutance", and avoid teaching "why and when to use inheritance". Of course, we'll give them a rough idea, but that's it.No more.

Within 4 months it won't be easy to make them familiar with only the language resources. So trying to teach them SRP (which concerns with only WHYs and WHENs) isn't really feasible. Move those to the next semester, and focus on teaching them simple programming logic, language resources and OO thingies (PIE).

BIT0112-Rokon wrote:I think, SRP should not included. First let them violate the principal, let them do some bad codes, then let them know its a bad idea, so that they can get a strong reason. But as very first, if you let them know its a bad idea, may be they will not get the point why this is bad to violate SRP.

BIT0130-Shakkhor wrote:I agree with Rokon.We should teach them "how to use inherutance", and avoid teaching "why and when to use inheritance". Of course, we'll give them a rough idea, but that's it.No more.

Those were convincing. Lets see if some one esle has something else to say.

I agree for the current extended time allocation for PIE.

We must plan such a way that they have to type a lot of codes by themselves. How to acheve that is up to individuals of us. We should plan well before delivering a lecture.

Completely disagreed. We are supposed to teach them in an incremental method. Isolated practicing of coding which can not be related from one class to another might turn out to be a dangerous decision.

I agree with Shakkhor and Rokon's reasoning about SRP and others btw.

Completely disagreed. We are supposed to teach them in an incremental method. Isolated practicing of coding which can not be related from one class to another might turn out to be a dangerous decision.

Yeah, you are right. But you do not disagree with this part, right?:

We must plan such a way that they have to type a lot of codes by themselves.

Hmm, right.

I have a proposal, which came to my mind after I discussed with Rayhan for a while.

Apparently, right now we are considering that only one person will give lecture per day(at least, that's what the plan is till now).

But we didn't consider that this is going to be a lab oriented lecture.

My proposal?

Right now, we have 9 people as possible student lecturers.


I think there are 4 who have free time on Saturday, and the other five has free time on Sunday.

What I propose is to use all of them on Saturday and Sunday respectively. the lecture can be given by a single person, or by a selected number of persons on that day.
However, instead of one senior person helping the whole batch, if we divide the whole class in several random groups on that day and then help them in the programming part, greater attention can be provided.

BIT0122-Amit wrote:instead of one senior person helping the whole batch, if we divide the whole class in several random groups on that day and then help them in the programming part, greater attention can be provided.

This was exactly what we proposed Sakib Sir We considered it to be the strength over one single teacher monitoring the class.

I didn't see that part mentioned anywhere in this topic explicitly

So, what's the plan for tomorrow?