Questionnaire .ac.rs
Questionnaire
Lecture title: Threads, Klaus Bothe, Ioan Jurca
Lecturer: M. Ivanovic
Semester: Summer 2006
I. Effort
1. How many hours did it take you to post-process the lecture?
2. year
▪ About 20 min
▪ 30 min – 2
▪ 1 hour – 2 Convergate to 1 hour (I think more than that)
▪ 1.5 hours – 2
▪ 2 hours
2. year
▪ 30 min
▪ 1 hour - 2
▪ 1.5 hours Convergate to 1.5 hour (I think more than that)
▪ 2 hours
▪ 2-3 hours
3. year
▪ I was already familiar with the content of this lecture.
▪ Less then one hour
▪ 1 hour
▪ about 2 hours
▪ It takes a couple of hours to cover the offered material, followed by a few days of individual practice to truly understand it and be able to use it in practice.
3. year
▪ Less then 1 hour
▪ 1 hour
▪ Much more compared to the other lecture, but this one offers more information, so the time is well used.
x. year
▪ Not too much, the lecture is easily processible.
▪ 1 hour
▪ 2 hours
▪ 2 hours to get familiar with basic concepts. (I think it is more realistic)
x. year
▪ 1 hour - 2
▪ 3 hours
II Contents of the lecture
1. Do you consider the amount of knowledge offered in the lectures
too much ( ( ( ( ( too few?
2. year 0 1 2 5 0
2. year 3 2 2 0 0
3. year 1 0 0 5 1
3. year 5 2 0 0 0
x. year 0 1 6 0 0 Most of them think that amount of knowledge is few.
x. year 5 2 1 0 0
Most of them think that amount of knowledge is much.
2. How do you consider the contents of the lecture?
too easy ( ( ( ( ( too difficult
2. year 0 5 1 2 0
2. year 0 0 2 3 2
3. year 1 4 2 0 0
3. year 0 2 1 5 0
x. year 0 3 3 1 0 Most of them think that content is well balanced.
x. year 0 0 2 3 3
Most of them think that content is rather difficult,
3. Is the course well-structured?
very well ( ( ( ( ( unstructured
2. year 1 1 4 2 0
2. year 0 1 2 4 0
3. year 0 4 3 0 0
3. year 2 3 0 2 0
x. year 1 4 2 0 0 Most of them think that course is well-structured.
x. year 0 0 3 5 0 Situation is not clear, half of students think that course is good
structured but half of them think that course is not god structured.
4. Are there any special requirements (pre-knowledge) to be able to understand the course? If there are, which ones?
2. year
▪ Basic Java knowledge X2
▪ Object – oriented programming tutorial. Thread tutorial.
2. year
▪ Basic Java knowledge. - 2
▪ Basic Java pre-knowledge is an absolute minimum, even medium pre-knowledge is recommended.
▪ Since this was the second lesson, it was easier to understand the basics. If I had not attended first lecture I would not be able to follow the lecture.
3. year
▪ Basic Java programming.
▪ Basic Java programming, some knowledge of processes (existence).
▪ Rudimentary knowledge of Java and OOP principles.
▪ At least basic Java knowledge (minimum one semester Java course).
3. year
▪ Java coding.
▪ Basics of programming in Java.
▪ Just the basic Java knowledge (1 or 2 semesters of practicing Java is enough).
x. year
▪ Just basic Java knowledge and perhaps something on processes.
▪ General Java knowledge.
▪ It is necessary to know Java language specification, as well as to have some experience in Java programming.
▪ Only basic knowledge of object-oriented programming.
x. year
▪ Nothing special, only knowing Java language specification and some minimal experience in programming in Java.
▪ General Java knowledge and very good concentration.
▪ Basic knowledge of Java and threads. If you are a complete beginner, it’s not so easy to follow the lecture.
▪ Basic understanding of multithreading and extensive knowledge of Java.
▪ You should be familiar with the topic, so you could understand all the details.
General remarks and suggestions concerning section II:
2. year
▪ The amount of knowledge offered is really enough for one lecture, but I think it would be better if there was one more lecture with additional explanations.
▪ More examples are needed to illustrate the usage of threads in Java.
▪ Good starting point for further studying. Still, some important definitions, explanations and examples are missing.
▪ I believe that some very important points concerning threads in Java have not been considered in this lesson. For instance, methods notify and notifyall. More should be said on priorities, thread creation, grouping etc. Nevertheless, first steps in using threads are presented very well.
▪ In my opinion, the lecture style and the presentation order should be modified so that students can understand the topic more easily. Some real-life examples (complete code) could be useful, as well. Although I have understood the basics, I am not sure that I could use threads on my own.
▪ Much more information is needed for real thread usage.
2. year
▪ There is a lot of new information in this lecture, too much for one lecture, especially if it’s the first lecture about threads. It was difficult for me to stay focused till the end.
▪ In my personal opinion, the lecture was too difficult to follow. There are too many complicated explanations and examples. No interesting and simple examples here, as well as in the first lecture.
▪ Content is a bit confusing. Much wider approach than in the first presentation. Lots of details, some of them not well explained.
▪ All important topics in working with threads are covered. I think students can get fully acquainted with the concept and with all the details they get, they can easily start programming with threads. The lecture is complete; every bit of information should be always used as a part of the presentation.
▪ Some introductory parts of the lesson were presented too fast, so (for beginners like me) it was difficult to understand more complex and abstract issues.
3. year
▪ As an introduction to the topic, the lesson seems fine, but not as a complete programming guide. For two-hour lecture, the content fine.
▪ A good starting point.
▪ Some topics were only mentioned or left completely unexplained. Nice start, though.
▪ Terminology used in the topic should be explained before starting the lecture.
▪ It is simple and not enough for understanding Threads.
3. year
▪ Maybe a bit too much for the beginning and just a two-hour lecture.
▪ The lesson should be structured better; some additional graphics and colours would perhaps make it more interesting. All in all, a rather boring lecture.
▪ The amount of information per slide is huge. Splitting some slides would help.
▪ It is all too big, confusing, almost terrifying.
▪ It is excellent presentation.
x. year
▪ Basic concepts are thoroughly covered, but it is left unclear how threads terminate. Runnable interface deserves additional comments. Notification concept should be mentioned as well.
▪ There are several important things missing in this lecture (such as interface Runnable) but lecture is very well structured and students can follow it without any problems.
▪ The content of the lecture is good and not too hard to understand, but amount of knowledge offered is not very large – some methods were not presented, that should definitely be included.
▪ This lecture can provide us with only very basic knowledge, which is not enough for programming on our own in practice. We should see more complete examples. Some parts of the topic are missing, for example methods stop and destroy, synchronisation problems and other complex issues.
x. year
▪ The content of the lecture is very useful and interesting, and not difficult to understand. Maybe some more examples should be added.
▪ If you are really concentrated and practice a bit more later, you can start writing your own programs with threads, although there is too much material presented in just 2 hours. It is useful, but with additional practical work and a lot of time to post-process the lecture.
▪ Bad-structured lecture (you learn about synchronisation and priority of threads without knowing why is it important in the first place). If lecture was better organized, it would be easier to understand it, this way it is more confusing than educational.
▪ Structure of the lecture is very vague and students can’t follow the ideas presented through the lecture. Too many concepts are introduced without examples and their connection is not obvious. Slides demand a lot of lecturer’s engagement, as well as many expected questions from the students.
III Style of the lecture:
1. Is the lecturer familiar with the contents of the lecture?
very well ( ( ( ( ( not so much
2. year 4 4 0 0 0
2. year 4 3 0 0 0
3. year 5 0 0 0 0
3. year 4 1 0 0 0 I think that generally lecturers teaching java are familiar with the
x. year 4 1 0 1 0 contents.
x. year 1 2 2 1 0
2. Do the lectures seem to be well-prepared?
very well ( ( ( ( ( not so much
2. year 2 6 0 0 0
2. year 2 5 0 0 0
3. year 3 3 0 0 0
3. year 2 1 2 1 0 I think that generally lecturers teaching java seem to be well-
x. year 4 1 1 0 0 prepared (.
x. year 1 0 4 1 0
3. Is the lecturer engaged?
very well ( ( ( ( ( not so much
2. year 0 7 1 0 0
2. year 0 6 1 0 0
3. year 5 0 0 0 0
3. year 3 1 1 0 0 I think that generally lecturers teaching java are engaged.
x. year 4 2 0 0 0
x. year 2 1 2 1 0
4. Is the lecturer willing to answer questions asked by the students?
very well ( ( ( ( ( not so much
2. year 5 2 0 1 0
2. year 4 3 0 0 0
3. year 5 0 0 0 0
3. year 4 1 0 0 0 I think that generally lecturers are willing to answer questions.
x. year 5 1 0 0 0
x. year 3 2 1 0 0
5 Is the presentation of the lecture
too fast ( ( ( ( ( too slow?
2. year 1 1 4 1 1
2. year 1 3 2 1 0
3. year 0 1 3 1 0
3. year 1 1 2 1 0 Most of them think that dynamics of presentation is good.
x. year 0 1 4 1 0
x. year 1 2 3 0 0
6. Does the presentation style encourage you to follow the lecture?
very well ( ( ( ( ( not so much
2. year 3 4 1 0 0
2. year 0 2 2 3 0
3. year 2 2 2 0 0
3. year 1 1 1 3 0 Most of them think that style of both presentations encourage
x. year 0 5 0 1 0 them to follow the lecture.
x. year 0 0 0 3 3
General remarks and suggestions concerning section III:
2. year
▪ The pace was ok.
2. year
▪ Nothing to complain about. It was hard to follow because it was the latter presentation.
3. year
▪ The lecture is carefully prepared and well planned, though maybe too basic.
▪ Very good style of presentation and slides, but it can’t replace lack of important conent.
3. year
▪ These slides change too seldom, which makes the lecture monotonous.
▪ Content is good, but presentation has to be improved.
x. year
▪ The presentation style is bad and does not encourage students to follow. There must be more shiny and soft colours (colour of background is very annoying). More animations are also needed, so people would not get bored. Lecturer had answered almost every question asked by students. Lecturer’s personal experience in working with threads in Java provided us with answers even if the questions had little to do with the lecture and slides.
▪ The lecture is perfectly balanced, easy to follow, with efficiently presented examples. Teacher’s lecture style can greatly influence the students’ understanding of the topic. We had the privilege to hear a very competent lecturer.
▪ Examples are simple enough, which is good for the beginning, but some additional, more complex examples could be even more useful for figuring out the real strengths of threading.
x. year
▪ The presentation style is very bad, colours are dull and boring, and there is too much content in every slide. The lecturer was good, though, and answered all the questions that emerged.
▪ This lecture was not interesting at all. Maybe I was a bit tired, but all the time I felt like I was reading a very boring book. The examples are good, but they are not presented very well. Too much information, overloaded slides, not promising at all.
▪ Lecturer was good but because of the bad style of the lecture itself it took more time to explain all the concepts. The lecture is too theoretical, not challenging the students to really think about the topic, I believe it even hard to follow.
▪ No introductions to the sections, or obvious connection between the slides.
IV Using media
1. Is the amount of information on the slides adequate?
very well ( ( ( ( ( not so much
2. year 1 4 1 2 0
2. year 1 2 0 4 0
3. year 1 1 2 2 0 Most of students think that amount of information on the slides
3. year 1 1 2 0 2 is adequate, for both presentations.
x. year 1 3 2 1 0
x. year 1 2 1 3 1
2. Are the slides well-structured and clearly-arranged?
very well ( ( ( ( ( not so much
2. year 2 5 1 0 0
2. year 0 0 1 5 1
3. year 5 2 0 0 0
3. year 1 2 1 1 2
x. year 4 2 1 0 0 Most of students think that slides are well-structured.
x. year 0 1 1 3 3
Most of students think that slides are not well-structured.
3. What is your opinion about existence of program code on slides? Please explain in details.
2. year
▪ I think that quantity of program code on slides is the best possible for understanding the concept.
▪ The code on slides is clearly explained and easy to understand, even for the beginners.
▪ In my opinion, there should be more program code – this lecture gives much more theoretical than practical knowledge.
▪ Code is explained well. It follows the pace of the course.
▪ Great program code presented during the lecture is irreplaceable when it comes to showing the point of the concept proposed and stressing out its strengths in real-life programming practice.
▪ I believe that at least one more complex example should be included, so that the theory presented during the whole lesson would be even better explained.
2. year
▪ The program code on slides is too complicated. The examples are not easy to comprehend.
▪ It’s fine, but there should be some more basic examples.
▪ The code is necessary for explaining the theory and showing the students how new concepts can be used in practice.
▪ The code on slides looks too complex, especially to the novices. It would be very difficult to write even the simplest program with threads based on the knowledge gained just during this lecture. More short examples should be presented as an illustration of every method.
3. year
▪ I think that there is enough program code.
▪ Program code in slides can be very useful to illustrate the theoretical concepts, but since these slides seem to be just the introductory ones, the code could be omitted.
▪ When speaking of programming code and its importance, if we are presenting something that will be used (written by the listeners) code is irreplaceable (as examples of usage).
▪ The examples do give a nice overview of the use of some basic functions, but are repetitive and unnecessary. They take up space and time that can be devoted to real (not constructed, out-of-context) examples.
▪ It is acceptable, as long as the amount of displayed code isn’t too great. It may be better, however, to run those programmes and then discuss their output, instead of having the output on the presentation slides themselves.
▪ The code should be more readable (by increasing font, presenting the examples on more than one slide each, etc.).
▪ Code is clear but too simple. After this presentation I could not write by mayself, code for more serious thread.
3. year
▪ Too much code. The main parts of it should be pointed out.
▪ Code is the best way to show practical examples if the goal of the course is to teach people to write their own code.
▪ It was ok, although I think that it would be better to show the code from *.java files, instead and place the links to these files in the presentation. In that case, it would be possible to run the code, and it would also provide the lecturer with a little more freedom – he could change the font size in the text editor if someone can’t see clearly, change something and re-run the programme, etc.
▪ The examples aren’t entirely intuitive.
▪ It is all too boring and complicated. More graphics and animations could help.
▪ The code is not well chosen if this lecture should be an introductory one for complete beginners. The examples are just too complex.
▪ The code is excellent and has been very well explained.
x. year
▪ There should be code on the slides, so we could see how to use the acquired theoretical knowledge in practice.
▪ Good introductory examples, but some more complex ones are needed to show the students the real applications of threads, as well as potential problems when working with threads.
▪ The code on slides is fine, the explanations as well, though some parts were presented too quickly.
▪ Certain (little) amount of code should be presented on slides, but only the important parts. Some code segments are hard to read (font should be increased).
▪ Program code on slides is very useful, since it is easier to understand the lecture with short examples. Program (fragments) should not be too long (and they are not in this lecture, which is very good).
▪ The program code is good and very helpful when a beginner is trying to understand the topic. But there should be more complex examples.
▪ There are some methods which are not on slides, but should be there. It's well-structured, but could be even better.
x. year
▪ It’s not bad, there is a lot of code on slides, but it’s still not enough. Program code is good for understanding new topics, but many students want to see how it looks in real programs, so there should be “live” examples. It’s not enough for students to see the code, they have to learn how to write similar programs on their own.
▪ The examples are very good, but they are badly presented, which makes them less efficient.
▪ There should be more code on slides, but with more explanations.
▪ Content of code samples is based on very good ideas, but its presentation is not so good, because code is written in too small font and key parts are not emphasized at all. Also, there are no accompanying comments on slides and they would be very useful to both students and the lecturer. Also, producer- consumer example is not very illustrative in the form presented.
▪ More code should be used. The examples are maybe too complex for understanding the main points.
▪ We received almost no intro on some procedures, but we have seen the code, which was not easy to understand.
General remarks and suggestions concerning section IV:
2. year
▪ I like the visual components on the slides - graphics, diagrams and images which help in understanding the lecture. One picture is better than a thousand words.
▪ Very nice slides.
▪ More examples wouldn’t hurt. Some of the important issues were forgotten
▪ Quite neatly structured slides. I like the examples and descriptions of their results. It is good that the most important part of program code is in red. Nice layout of the slides makes students pay attention to every detail. The lecture was interesting, students were involved in discussion. Very interesting lecture, simple and valuable examples. Well done.
▪ Good slides, well prepared. Interesting enough to keep students attention during the whole lesson. Very helpful illustrations and animations.
2. year
▪ I think that there is too much text in this lecture. Maybe it would be better if there was less text and more images.
▪ Some slides definitely need animation.
▪ Just a little bit less details could be better for most of us.
▪ The slides are overloaded, with too many details, but without stressing out the main points. They are a bit dull, so they fail in keeping the students’ attention during the lecture.
▪ Slides were rather boring, overloaded and not too attractive. More colour and animations could perhaps help making the students pay more attention to them and understand more of the material presented.
3. year
▪ The slides are attractive and focus well on the important things. They should keep the attention well and help understanding the lecture.
▪ The examples requesting the output data from the students are very good and illustrative of the ideas and processes involved in programming threads. But some important code was skipped (more talk on synchronisation and locks… mutex was not even mentioned).
▪ Perhaps to add graphical representation of crucial examples. It would interest the audience and lead to the better understanding of the topic.
▪ Nice design, without too many unnecessary details. High-quality charts and pictures.
▪ I suppose that examples are simple because students have not enough experience in Java programming.
3. year
▪ More graphics, schemes, animations and simple examples would make the lesson easier to understand.
▪ The slides are too crammed; too much text is shown at a time, which makes it harder to focus on the current topic. They probably should be split into more slides.
▪ Some slides contain too much information. Two more lectures could be made out of all that material. The sixth (final) part is very good and informative.
▪ Presentation gives appropriate knowledge, so students are able to write complex thread programs.
x. year
▪ A lot of graphics and useful examples.
▪ Slides are very well organized and it is clear what the author wanted to present. Diagrams show basic ideas in clear, easy-understandable manner. Demos could be more effective than screenshots of program outputs, especially when there is a chance that repeated execution of the same code can produce different results (as in ThreadBasicTest.java, ThreadPriority.java, etc.).
▪ The amount of information and the structure of slides are just as they should be, lecture is easy to follow and there are not too many new pieces of information.
▪ The presentation contains useful information students should know if they want to become good programmers. Synchronisation of threads is very interesting, so it could be covered in more details.
x. year
▪ Slides are full of data. It is boring to pay attention to one slide for 20 minutes. There should be more animations on slides to make them more interesting to the students.
▪ It would be better to have more slides but with better arranged material. This way they look really boring and it is really hard to follow the presentation.
▪ Text is written in too small font in most of the slides and keywords are not bolded so it is very hard to process the information given. Absence of diagrams and images makes concentrating on whole lecture a very difficult task. Also, too many technical details are present on slides. They could be replaced with references to other resources, such as javadoc.
V Benefit of the lecture (or value, profit, usefulness)
1. Did you learn a lot of new things?
much ( ( ( ( ( not so much
2. year 3 2 0 2 1
2. year 1 6 0 0 0
3. year 0 1 0 4 2
3. year 0 2 3 2 0
x. year 1 6 0 0 0 2nd year students learn a lot of new things.
x. year 3 3 2 0 0 3rd year students alos learn some new things.
2. Do you think the content of the lecture is useful?
completely ( ( ( ( ( not so much
2. year 4 2 1 0 1
2. year 2 4 1 0 0
3. year 2 1 4 0 0 Most of students think that content of both presentations
3. year 2 3 2 0 0 is useful (of course more useful for 2nd year students).
x. year 4 3 0 0 0
x. year 2 2 3 1 0
4. What is you overall rank of the lecture?
very well ( ( ( ( ( bad
2. year 1 5 1 1 0
2. year 0 2 4 1 0
3. year 0 3 2 2 0 Most of students think that lectures are well, but NOT
3. year 0 4 2 1 0 VERY WELL (.
x. year 0 6 1 0 0
x. year 0 1 2 5 0
General remarks and suggestions concerning section V (e. g. which topics did you like best - and why, which are not so important or not so interesting, which deserved more and which less attention/duration).
2. year
▪ Good for novices. Should be more platform oriented (code should be optimized for x86, x86 64, E64T and all other platforms. It will work, but will it work fast enough?).
▪ I like how almost every method is explained in details, but I believe that the synchronisation part should be introduced a bit earlier.
2. year
▪ It is a lot more difficult to understand then the previous lecture. Therefore, it should be heavily modified.
▪ Third part of the lesson is not explained in enough details. I believe it deserves more attention. At the same time, fifth part is too long and not easy to understand.
3. year
▪ It is all matter of opinion, but generally the material presented during the lecture is potentially useful.
▪ The lecture is a nice intro to threading, it nicely highlights most of the important concepts, but it is far from a “user manual” in a sense that the listeners aren’t prepared for writing their own code after the examples given in the slides.
▪ Best parts: interactive questions. Bad: too much repetitiveness! The diagrams and the code are maybe unnecessary in some cases.
▪ In my opinion, more should have been said about synchronization methods. Discussing order of execution and unpredictability of unsynchronized multithread programs was nice, but it should have been given as a briefer overview.
3. year
▪ It shows enough code and examples, so it can be a sort of a “user manual”, but it maybe should show more results of the examples, how the programs really work, etc.
▪ Although there was a lot of information on the slides, it was a bit counterproductive, since it was better to just focus on the really important things, stress them out, and only to mention the rest of the details.
▪ The part which explains notify and notifyAll seems to be the most complex and boring one.
x. year
▪ Considering the fact that I was already acquainted with threads, the lecture was a nice reminder of certain points. If I were a total beginner I believe I would learn a lot of basic things.
▪ More attention should be paid to some special issues, such as synchronisation.
▪ Introductory slides about multithreading are very good because they explain main ideas without going into details about structure of the operating system. Also, many diagrams, sources and outputs of the programs give students a very good overview of the subject. All topics, except for the interrupts maybe, are clearly presented and with little additional reading one can implement basic multithreading in his program.
▪ Examples are the most interesting part of the lecture, because they show how computer works with threads, where to be careful, and why threads are important.
x. year
▪ Content of the lecture is very useful and very good. Synchronisation of Java threads is very interesting and should be illustrated with complex examples.
▪ I have repeated basic issues, even learned some new details, but if it was the first time I heard of threads it would definitely only make me confused and with no optimism to continue working with threads. The lecture is too confusing, which is actually a pity, since it contains a lot of really useful details and high-quality examples.
▪ A lot of useful topics are covered, but it is done in very unclear manner. Many ideas are only briefly mentioned on slides but their use is discussed in great details on the last two slides, which are totally unnecessary.
▪ Synchronisation is explained in a very nice manner, but there are many other issues that deserve the same kind of attention.
▪ The pace was too challenging, a huge amount of information was presented, bat often not properly explained. A lot of new data, but badly structured. It got all mixed-up in my head.
Final general remarks to the lecture:
2. year
▪ Ideal for complete beginners. One additional lecture, covering advanced issues, would be very valuable.
▪ Nice lectures for the beginners. Sharing processing time and life cycle of threads is well explained. For advanced listeners, the lecture is not interesting at all.
▪ I find it useful. It gives you some basic knowledge, and I feel I could make some (not that complex) programs which would include several threads.
▪ The lesson was very well presented. A few additions and some extra practice would give us a proper knowledge of the topic.
2. year
▪ The lecture should not be used for total beginners.
▪ Too complex, lots of useful information, but lousy presented. Terminology is introduced without examples, so the first part is difficult to understand. It could be a useful lecture, but only for student with some pre-knowledge.
▪ After the first lecture, I could write some basic programs including threads. After this lecture, I tried to write some not that simple programs including threads, but it was much more difficult and I had a lot of troubles making them work.
▪ I did not really like this way of presenting threads in Java. The amount of information presented would be enough for at least two lectures (with some additional examples and explanations).
3. year
▪ Good slides, interesting and well designed. Just the right quality and quantity for a two-hour lecture. More effort is needed in order to use the proposed concepts in practice.
▪ Good as an intro, and I think that in 2 hours nothing much more should be said – these are complex concepts and students need time to understand them.
▪ Details are often missing, which leads to difficulties in understanding certain issues. The material and the lecture pace is very challenging, students are required to instantly acquire new and abstract knowledge.
▪ Good introductory lecture, but it just scratched the surface of the topic and it does not offer enough knowledge to start programming with threads. I also believe that thread communication and synchronisation should be introduced earlier, almost at the beginning of the lecture, since introducing them at the end leaves the students confused and with a lot of questions unanswered.
▪ Sinhronization is completely avoided . I think that it is weak point of presentation.
3. year
▪ The lecture shows a lot about threading, though it is maybe too much for 2 hours to understand it all. It should also be a bit more dynamic (shorter slides keep attention better).
▪ Monotonous lecture, too long as well (or it is so boring that it seems to be too long). The material could have been presented in several lectures, as a part of an advanced Java programming course.
▪ Too complex presentation, at least for an average student.
▪ A lot of new terms are introduced without proper explanations. It is a rather advanced course and should not be used for teaching complete beginners.
▪ Excellent content and organization of material, but slides have to be visually improved.
x. year
▪ Lots of information, but not enough time.
▪ The lecture was well structured and the knowledge level was intermediate, so it was very easily followed. Some things were over-explained, though.
▪ I generally liked the lecture, especially the illustrations and adequate examples. Perhaps I would add some animations to make the explanations of processes even more picturesque.
▪ This lecture is very well suited for covering the basics of threading as a part of introductory Java course. Perhaps it would need to cover additional topics to be used as a part of same advanced Java course.
▪ Very good lecture, only few important things are missing, but in general the lecture is interesting and very understandable.
▪ The lecture is very useful. Maybe it isn’t easy to understand the way how we can write programs after this presentation. The style is bad, colour of background is annoying, and definitely should be replaced (maybe blue, or some colours that are very shiny). We still learned very useful things and the lecturer answered every question we asked.
▪ A good presentation is the one that leaves the audience with all their questions answered, the one that is simple but interesting enough to keep students attention till the very end of the class. The students could get even more interested in the topic if they are presented some real-life problems and solutions, which use the theory presented, especially if those examples could be somehow visualized. This lecture should follow a complete Java course, since it is presenting an advanced technique.
▪ The lecture should contain just enough material in order to give the students all knowledge necessary to start programming on their own and using new concepts, without going through additional literature.
x. year
▪ The lecture is very useful. It is good to know how concurrent programming works, and how we can control them (threads). Style of the presentation is bad but with some changes, it might be much better. The worst points are the style of slides and too much information per slide.
▪ I believe that more attention has been paid to what is presented than to the way it is presented, which is also very important. The material presented to the students was honestly too much to process in just a couple of hours. The information was well chosen, the examples too, but the slides that were supposed to present them are far from efficient.
▪ There are many things (and interesting things) in this lecture but because of the very, very badly arranged slides you can’t enjoy the presentation. If the lecture was differently organized it would be much better.
▪ It is obvious that these slides are prepared for very advanced students who are already familiar with the subject and could use them as a quick reference. In that case, a few of the introductory slides could be skipped. Other students would find the material very confusing almost form the slide 1. They would need a lot of additional materials and coding and testing small examples to understand the basics so they could move on to problems of synchronisation and thread management that are discussed on these slides. Slides themselves are more suitable for a book chapter (with small extensions) than for a course lecture.
▪ The lecture is very confusing. It should contain a longer introduction about threads and processes, with animations and demonstrations do that the students could understand what is happening when using them and how to make the best of it.
▪ I didn’t like it, and I think it was quite hard to concentrate on it.
................
................
In order to avoid copyright disputes, this page is only a partial summary.
To fulfill the demand for quickly locating and searching documents.
It is intelligent file search solution for home and business.