Previously on CS410J...
We were all 100% remote in the Summer of 2020 because of the
COVID-19 pandemic. It was a unusual and challenging experience
for everyone. A lot these observations are relevant no matter how
the course is offered.
- What do you wish you had known before taking this course?
- I wish I knew more about Android development and the REST architecture and how each class is connected.
- OOP, design patterns
- Wish I would have known about intelliJ a little more.
- I really wish I knew how to use git. As I had git merge conflict issue. Due to which I had to rework on my assignment from the scratch. Had I knew how to use git well, it would have saved half of my time.
- I think with the amount of work involved it would have been better for me to take during a 10 week term.
- If I take this class again, I want to learn the unit tests before this class, I never build the unit tests before, and when I take CS 300 it suppose us to learn the unit tests by ourself, but I cannot even understand the code very well in the process, so I do not have a chance to learn it. When I take the capstone, we still do not make the unit tests, we just focus on how to make the project run successfully. When I took the CS 545 software engineer exam, I was really sick and I miss the unit tests again. This class is the first time that I know about the unit tests, and I can contribute them by myself. But by missing experience, I lose many times on how to build them. Although you already showed us the example of unit tests. I still use my time on them. Second, I should learn the process or plan to build a project in Java. It is one important part, as we already make many projects right now. I know if people get a great plan before typing the code, it can avoid many troubles and faults in the process. For example, I still remember the project2, we used the text dumper to save the information into the txt file. I should test each part like if the file does not exist, if it already exists, if the input information is incorrect. If I can build the code with unit tests that can test all of the situations that might happen in the process, I think I can make the code become more powerful. Third, I will become a careful person , I lose many points on unfriendly message that show to the user, once because I really forget it and I just add error trace on the command, I did not watch the description carefully, I think if I have a good English skill, I will not lose the patient to watch the description. And if I spend more time on the description, I will know about how to avoid losing credit in this class. Second time, I lost points for the same reason, the professor already signed the description that it should use the parameter with the given string on the description, but I lost it and used the parameter name that I built by myself. I find out all the process that I lose points because of stupid problems, I really want to become a careful person now.
- Thir is no additional special topic that i had to know in paticular befor joining the course. the courses teaches you to all the required topics.
- some android development knowledges
- I wish I had reviewed Java a little more before beginning. The Koans and lectures helped refresh the details, but it would have been helpful to review before hand as well.
- android programming and test driven development
- I wish I had known a bit more about HTML and web implementations prior to taking this course. While I learned a great deal about this during Program 4, it may have helped knowing a bit more about the HTML protocol, specifically. Since getting and posting were the only two REST components we needed to implement, though, this wasn't a huge burden.
- I wish I had known unit testing before taking this course, because it's a big part of our projects, and it helps improve my code quality. I also wish I had known how to deal with command-line arguments before taking this course because I wasted most of my time refactoring it.
- Whether intentionally or not, the assignments are examples of poorly-structured writing. I wish I had understood this from the beginning; I would have approached the projects with a much closer reading of the spec and a formal requirements process, and this upfront investment very likely would have been rewarded with a smoother learning experience.
- I wish I had know more about TDD.
- I don't feel there was anything I wish I knew beforehand.
- Unnecessary code only hurts your score sometimes. I probably just missed this though.
- I probably should have realized how fast fast-paced it was. It's a lot for an 8 week course. I did look over the website before, but didnt start working on anything. Perhaps i should have practiced or something.
- I wish I knew more about Android development before taking this course. The last project was kind of tough because I didn't know anything about Android dev before I started it so I had to watch a bunch of tutorials.
- I wish I had experience writing tests before this course! I think that a lot of the first week was spent familiarizing myself with the testing process and how to design tests that were a good reflection of the code's expected behavior. It definitely took some time for me to feel comfortable writing a valid test.
- Just that I had brushed up on my Java a little more before taking. I think the Koans benefited me a lot in that way. It helped solidify some concepts.
- I wish I had known that the course did not start with the advanced Java topics. At the start of the term I was really scared because of my limited experience with Java, but the course was awesome in that it started with some fundamentals and built upon that. Working through the Koans was also really helpful. Had I known how the class was taught, I would've been able to save myself from worrying so much.
- I think the expectations for this class was well-covered on day 1.
- I wish I had been more comfortable/practiced with basic java syntax and introductory concepts like exception handling and common coding practices for java.
- Honestly nothing really. Koans helped me learn the syntax quickly, and the lectures covered almost everything needed in this class.
- Android
- Nothing in particular.
- That there was not a TA.
- IntelliJ as a tool, and loosely related, the Maven build/workflow. Largely a VIM and linux fan so, this IDE was daunting at first, though I have used others for Windows development.
- There's honestly nothing that I wish I had known before taking this course. I like how we all started off at different levels of Java proficiency, and quickly became better for it.
- This is tough as I would say that I didn't know much about Java beyond general C/C++, so I can't really think of anything that I needed before this, maybe general object-oriented ideas will help the beggining be easier
- I wish I could have started early on the Koans and IDE setup, just from a time management standpoint. If I had to get into more details about setting up Maven and the template programs, it would have been a whole other layer of knowledge I was unfamiliar with. I also wish I'd spent just a couple of extra hours on REST before class, so when Project 4 came around it would have a review component too.
- Don't take more than 2 programming intensive courses in a summer quarter! Every week felt like a struggle.
- More about Android!
- How to work with maven and gradle. Caused so much stress being new to it when it was time to submit the code.
- I wish I had a better understanding of test driven development and the git workflow before begining this class. Though I loved the way this class really got me to brush up on both of these things. I just wish it wasnt such a struggle in the first couple weeks.
- It is a dense programming course.
- It is important to keep backups of your hard drive, because it's gonna die when you least expect it.
- POAs were due 3 days before the programming assignments
- A bit more about advanced java concepts, like java servlets, java web application. Also, a bit more about android concepts, so that the projects would be a bit easier for me.
- I felt adequately prepared to take this course. (it's my very last CS course at PSU)
- I feel like this course provided me with everything I needed to know.
- I wish I had been more prepared for the Android development portion. I wasn't expecting it to be so different!
- Web and android knowledge
- I wish I had known about HTTP communication because it takes much time to figure out how it works.
- I wish I knew git/github and intellij pretty well. Also having the skills to find how to use libraries, APIs and documentation quickly.
- I wish I had known how time consuming this class would be. There really weren't any pieces of technical knowledge I was missing. Even though my only exposure to Java was two years ago in a single tiny project, I was able to catch up by practicing.
- Java syntax
- I wish I knew more about Maven and other software project management tools.
- Knowing more about maven and other related tools would've been helpful in getting started. Maybe having a little more familiarity with Java would be nice as well before diving deep on it
- What is the most important thing you have learned in this course?
- Test-driven development and the important process of asking good questions to understand what the client wants better.
- TDD, Collections, IntelliJ, Maven, RESTful API
- How to be self sufficient and learn to troubleshoot and debug. I also learned how to write code using test driven development.
- I've learned a lot about the java language.
- I think there are too many important things that I learned from this course. I want to explain them then. First, the most important thing is unit tests, when I know how powerful that unit test shows to me, I fall in love with it, it can help programmers avoid many troubles and save their lives in the process. I think if I want to become one software engineer in the future, I cannot avoid touching the user, the user might try many inputs that they want, the hacker might steal the information from the processing. It all needs to build the models to test different situations. And also, this is the first time that I use the intelliJ often. It is one powerful IDE that people can use less time on files. The IDE can make many different operations on the project, and avoid to waste time on finding out the different files. I think I don't know about the unit test because I did not use the IDE always, because I have less experience with Java programming, so I lose times on it, and after take this class, I think I can use the Java easier and the IDE can support me to make different operations with safe model. It can display the faults on the type windows, the run time error can be found in the unit tests part. Second, I think it is the way to type java in a good process and plan. Project with run time error is really trouble in the process for programmers, I was not a programmer with a habit that setting the error message, so I might become confused and anxious when I thought my program should run successfully and waste lots of time on finding out the faults. When I took this class, at least, I knew I should check each situation and make sure which input showed a pass or output error. To summarize, I think unit tests and programming habits become my most important features learned from these classes, and I will focus on using them in different classes.
- The most important things I haven learnt is maven, web and android.
- In this class i did java projects uaing maven, worked with web (java servelet) and now android. Along with these individual projects, i also got a chance to do pair and mob programming. Their are a lot of new things i got to do in this course and in each of them i got to explore various different topics, subject wise and personally it helped me understand myself better while doing group programming.
- using Java core API, android developement
- I believe that the exposure to industry techniques such as test driven development, and pair/mob programming are the most valuable experiences I had during this course.
- Test driven development and restful services
- The programming assignments on web and Android seemed very applicable to real-world projects, which had been lacking to this point in my coursework at PSU. While difficult and time consuming, these were very satisfying projects to complete, as I feel they prepared me more for programming in the workplace.
- The most important thing I have learned in this course is handling errors. I experience how to use exceptions to handle errors, and exit gracefully with a user friendly error message instead of printing out the stack trace message. I also experience the difference between checked and unchecked exceptions.
- I have a much deeper appreciation for the peace of mind offered by a good suite of unit tests. Runner-up: I take my git skills a great deal more seriously than I have in the past.
- The most important thing I learned in this course is unit testing and TDD
- The Android project in general was a very beneficial project to work on, as it was challenging and fun, and I learned what I feel to be the basics of an entirely new skillset with Android programming
- How to make proper unit tests.
- I think i have learned a variety of concepts that wil prove helpful to me in the future. The REST api project was important and is going to help me be ready for the REST stuff I might be doing at my internship, though theirs is a little different.
- I think the most important thing I learned was test driven development.
- That being said, utilizing TDD and having to write unit tests for the first time has been life changing. Frankly I'm shocked that we aren't exposed to testing our code in any of the under division courses considering how significant it is when you start working in industry. Starting out writing a test that should verify the expected behavior of the code has been a paradigm shift that I believe has improved the quality and organization of my code. In fact, I think I will continue to use TDD for the next class I'm in!
- The most important thing I have learned in this course was everything I learned in this course. I learned how to pair/mob program which I had never done before. It helped me get out of my comfort zone and when I did I realized I knew a lot more on the spot than I gave myself credit for. The android project was very new to me and I learned a lot. I feel like I have an overall much better understanding of Java and I feel really comfortable programming in Java more than any other language now. Overall this class was challenging for me but now looking back it was really fun too.
- Android development was one of those things that I had looked into in the past but was overwhelmed with information. So I feel like the most important thing I learned was from the Android assignment. My assignment needs a LOT of work on the aesthetics side, but I finally understand the basics!
- The most important thing I learned in this course was how to effectively program in Java.
- - Good coding practices and workflows. - Full Applciation development spectrum from command line scripting to command line applications to web applications to mobile applications. - Test driven development. - Real world client usable applications (web and mobile deployment).
- Program to an interface, and object composition (seperate responsibilities and combine later together to solve different problems)
- Advanced Java techniques like testing, using intelliJ tool, Core JAVA APIs.
- Test driven development, pair/mob programming, programming a Java servlet and REST API, and programming for Android. These are skills that are not usually taught as a part of the core CS curriculum, but are often used in the industry. I think this class has helped to prepare me for a job outside of academia, which is what I want.
- Java fundamentals and structure. Also this was my first experience with REST, which I am sure will come up in the future.
- Test Driven Development. Without question. Primarily using it as a workflow. Historically I would do testing after the fact, and that would work to get something working, but later on down the project life cycle, and refactoring would ocurr, the project may work, but use cases could have failed. This was most evident in Project 4, the REST API/Client version of the PhoneBill, as I imported java files from previous projects into it, and as changes were made, it was reasurring to know that I could "trust" the Class/Method to work as described after making changes
- It's got to be test driven development. Before this class, I always nebulously knew why it was important. But now, I realize that it's faster in the long run to do TDD than to not do it. Also, Uncle Bob was a gift. Right now I'm reading clean code by Uncle Bob. There's so much I'm learning, and I would have never even knew of this until I took the course.
- I think general experience with java, the whole practice makes perfect thing.
- Hard to nail it down to one thing, but all of the work on building tools with components composed of various classes and data getting passed around different ways has made me much more comfortable with the notion of actually working on non-trivial software projects. Not that I consider the phone record management systems to be commerical grade, but the way in which the programs were created feels more like real programming. The assignment giving actual specifications with just enough ambiguity to encourage creative thinking, and knowing that the output will be tested using a tool looking for very specific behavior, probably mirrors the experience of professional software development.
- If we try hard enough to get a program to work, it will! Sometimes I found that I would just be putting the projects off because of the thought of how much time it would take (weird, I know), but often once I got started, it ended up being sort of fun! I felt this way very much so with the android project.
- Java development patterns and Android development.
- Just general java information. How to properly throw and catch excpeptions, how to develop web apps.
- The most important thing I learned was the value of Junit and testing software as a way of developing better cleaner code.
- How to program java with IntelliJ and github repo.
- Things that seem completely outside of my capabilites aren't actually that hard once I put my mind to it (i.e. the android app, which I would have never normally attempted).
- Android Programming - I made my first Android app solo in this class which was awesome!
- This is the first time I have written unit tests and integration tests so rigorously. In my opinion the two most important things I have learned in the class are- documenting the code and how to work in test driven development.
- Unit testing and TDD. Period.
- I feel like the TDD workflow (especially in the java environment with mockito) is the most important thing I took away from this course.
- Learning a better workflow for test-dfiven development felt like a pretty important milestone.
- How to write basic web apps and Android apps
- Learning how to work with Java API, working between Java application and server and Unit testing.
- The adaptability of working in a not quite familiar environment ( working with command line, github and intellij together)all at the same time. Also the skill to find information that's helpful for the projects.
- To be perfectly honest, the most important thing I learned was how awesome IDEs are. I mean I learned a fair bit about Java too, but I wish I had known how much better creating and debugging code is when you use an IDE.
- Maven to manage project dependencies, gradle for android project , git, IntelliJ and java syntax
- The most important thing I learned was how to use API to do alot of the heavy lifting for my programs. Also how to do testing. Both of these thing I can bring with me to other courses and into my career.
- So many things, I honestly think this was one of the most useful classes I've taken. Learning how the web and http work, learning android, taking a deep dive into Java, it was all incrediby helpful and important in my view
- If you could give one piece of advice to someone taking this course in the future, what would it be?
- Start your projects as early as possible and dont' take any other difficult classes. I recommend taking only 1 other class.
- There will be many works to do, and you'll practice a lot, having some pre-knowledge like web development and Android development can help.
- Start early on projects because there are a lot of road blocks to getting things working.
- As for my experience for this class, I think the first important advice is people should have enough time to take this class. I think this class educated many knowledge of Java and programming, but the pay and return are proportional, I almost spend 18 hours each weeks for the projects, the quizzes and survey will not spend many times, people can just talk their ideas and find the answer our the slides, it shows all of the results. But the project really takes a lot of time for students. Of course, if people are skillful programmers, then they can take classes they want. But if people are not familiar with Java, I think it might become a hard time. First, people should pay attention to the class, the professor will show how to code the program, he will show an example that helps a lot. If people missed, the project might lose many time on ask the stupid questions. Next we have many orders for this class, so people better check out the unit tests. Because the code is just one part, the unit tests almost take the size of program code, although many of the codes are the same as other unit tests. People still should take care different situations of input arguments. I have less experience with user input from the command line, so I just use the most basic method to check each input with a different if/else statement. The whole process of writing the java program takes a lot of time and power, I lose my patient many times. Also, I think this class is not good for people who procrastinate. I always spend half of the night on Tuesday night, because I think the project is easy and will not take much time from me, But the truth makes me lose time to sleep. So I think for people to take this class. It is better to have the capability to control the time, and not make yourself become too busy.
- Get started on assignments immediately.
- During the break, please clone and set up the git repo in local as well as linux system. Install intelliJ and practice project 0. Practice in the sense, build the project using maven, check 75% test coverage and java documentation requiremets. This will give you confidence in approaching your upcoming assignemnts.
- this term i took 2 programming intensive courses, which became a lot of burden to me. ofcourse, the courses were interesting, but their's a lot to focus on with 2 programmimg intensive courses. It is manageable in a stressful way. but if you want to enjoy the course in a peaceful way, just take one progamming intensive course.
- To setup you PC for Java development in advance! It really takes time!!
- I would advise people to give test driven development a try. It can be tempting at times to write the code and add the tests at the end, but I think practicing true test driven development is an important part of this course even if it means some unfamiliar development practices at first.
- My advice would be to take this course is not to take with other heavy work courses. Because adv prog in Java is really a lot of work.
- Don't wait until Sunday to begin a project that's due Wednesday! I ran into last-minute hangups with builds and submission that I wouldn't have ordinarily have factored into time needed to get a project finished. Even starting the projects the day they were assigned, as I often did, I often felt pressure as the due dates neared.
- If I could give one piece of advice to someone taking this course in the future, it would be better to use TDD for their project. TDD and unit testing would significantly improve code quality, and allow code to be more testable, and while at the same time it will keep high percentage code coverage from the beginning.
- Begin by building a suite of integration tests for requirements acceptance; then move on to the design and coding of the project. Also: if you think you understood the spec on the first reading pass, then you're wrong.
- Start your programs early! It allows you to test your programmer more theroughly and enjoy developing the project.
- Start the projects early and go through the screencasts.
- Start projects early!
- Sometimes the unit tests take longer than the program it self. Don't always just think the other way around.
- Ask good questions, and read the material before you start. Make friends.
- Start the projects early. They are challenging and may require more time than you expect.
- My one piece of advice would be to take advantage of all of the resources posted on the website and actually put aside time to review the materials before lecture. The resources are full of extremely useful and engaging material. If that isn't enough to persuade you, Dave pulls all of the quiz questions directly from this material. Honorable mention: don't forget that your POA is due exactly 72 hours before your assignment is due!
- You have to put a lot of work into this course but if you do you will genuinely come out a better Java programmer and that's worth it.
- Go back to view the videos and follow along on the slides. Pause the video to try out some of the APIs that are discussed.
- I would advise future students to get a head start on the projects. Initially, I definitely underestimated the amount of time and work that is needed for the projects.
- Start the assignments early and ask clarification questions often. Be prepared and watch the additional screencasts well before the class they are assigned to fully take advantage of lecture time. Don't wait to watch the recorded lectures later. In class participation is crucial to getting the most out of the course.
- Always start early on assignments, and reach out on slack whenever you have questions.
- This course has a lot of work.
- Listen to David, and get started early on the projects, especially in Summer term.
- Start projects asap, bookmark java APIs.
- Do NOT procrastinate. Not one bit. The amount of work involved is definitely worthy of a 410P course, and the fact that each week built upon the the previous week, was that much more important. Related to that, truly do take the koans effort seriously and do not wait on it either.
- Read all the small details. A lot of points I lost wasn't because my program was bad, or my coding didn't work, it was because I skipped over a tiny detail in the homework assignment. I think that's life though, so I don't mind losing the points. Better now than in real life.
- making sure to watch the pre-recorded lectures is very helpful
- If you're taking the course in the summer term, don't over crowd your schedule. You will want to devote a lot of time to this course, and it'll be worthwhile.
- Make sure you have the time required per week, there's lots of work and time goes by fast.
- Get Intellij and Android Studio set up well in advance. Maybe write a hello world app in each.
- If possible get familiar with maven and gradle prior to the class.
- Start early with the planning phase before projects, ask clarifying questions about the project and its needs and write out a list of things that should be tested so that you know where to start with the test driven development, diving in with code will only make life a mess.
- It will take a lot of time and effort on programming.
- After you get past the 'banging your head against the wall' phase of the projects (specifically the last two), they're actually pretty easy.
- Watch out for POAs! It's easy to forget that they are due 3 days before the actual due date.
- If someone is a beginner to Java, I would suggest to revise some of the basic concepts, like reading and writing to a file. Also, I would suggest to read about java servlets. As we have project due every week, it becomes a bit diifficult to get hold of these concepts and work on it in such a short period of time. If we knew it beforehand, I think it would be a bit easier.
- This course was really great. With the summer heat, I had a lot of trouble focusing during class, but I was able to watch the recorded lecture videos afterward. My advice is that project 3 and 4 are very large in both the amount of stuff you are learning and the code you have to implement, so get started on those ASAP. Allocate time to implement one function, one file, or just one unit test early on, so that you aren't SOL later on.
- Stay up to date with the current repo for pom patches and other things of that nature (not the repo you'll be cloning initially... there is one just for your term and thats where the patches will be pushed).
- Don't put off your projects until the last minute!
- Get started on the projects early and do a little bit every day
- This course should be introduce more about Android development. I know this is not main purpose of the course but learning about design pattern like MVVM, Redux is also neccessary with Android.
- I'd suggest learn git/github and intellij. Also, make sure you know how to program in Java already. If you knew how to unit test, then that'd be even better! I feel like having the unit testing skills would definitely help you to take a great leap in this class.
- Think carefully about your workload. This class is not "hard", it is "time consuming".
- It will be beneficial if you know java syntax.
- To treat it like the programming intensive course that it is. People approach Operating Systems in a very diligent way because of its reputation and I think people should do the same for this class. It's a lot of work, and in order to learn the material the right way and get everything done the time must be put in. It's one of those classes that you can't play catch-up in
- What made you stay in this course?
- Professor Whitlock cares about YOUR learning and his projects are setup as such. Also the practical nature of nature helped me develop my Java skills which will be helpful when I am in the workforce moving forward.
- Java is a main requirement for job oppotunities, and the dense homeworks sharpen my understanding of Java and OOP.
- I wanted to learn about Java and how to develop an android app.
- The in-class step-by-step implementation helps you gain confidence and even if you have some error, professor / peer will help you resolve it. Apart from that, office hours really helps as the professor gets to look at our code and give solutions. And there is slack for any other questions/doubts. All this gave me the confidence to stay in this course.
- I wanted to learn advanced java.
- I want to get better at programming.
- To be honest, before I took this class, one of my friends already talked about this class to me. So I have known about this class, it supports my plan in the future. As my personal idea, I want to learn another graduate degree in the future, I personally prefer to be a game engineer as my second degree. And as I know, less people contribute game design personally, most of people join in a group that is smaller with 10 to 15, the larger even has hundreds of people. Although, Java is not the first choice that supports people learning to be a game engineer. I should prepare the second way for myself. I found some friends that said they can help me to get an internship in their group. I can improve my software skills by this class. Java is one powerful language, I believe many companies use this language both in the USA and my hometown. And also, as I have learned computer science for 5 years, I believe if one person learns one programming language skillfully, the next language will become easier in the future. Although this class do not support the group projects, I think it teach the situation that people work together with the pair programming and mobbing programming. I knew it is popular and powerful method for groups. I take the agile class this term also, it shows the way that how group work together. As I want to make intern or make the game engineer in the future. I think the knowledge I should get and they can support me.
- I think it was a amount knowledge, manly knowing that you are going to learn/creating stuff that will be use in real world.
- This course is intensive, and requires a lot of work that need to be done. And the worst case is when we get bugs. But professor is quite responsive and helps each and every student to resolve their isuue and move on. I think that helped me to move forward with this course.
- To learn more advance Java usage.
- The chance to develop my Java skills while learning some new and interesting ways of working on software are what kept me in this course.
- Your way of teaching, developing the assignments and quick responses to the questions in slack.
- I wanted to learn java on a deeper level! Very happy with the information I learned.
- I had heard from other students that this was one of those courses that trains you more for the real-world than any other in the CS program. While it was very challenging and I had moments of feeling I was in over my head, it was clear from the reviews I'd heard that the learning made it worthwhile.
- The most important thing that made me stay in this course is because I want to learn Java. Java is a worth learning language that is popular and it is widely used everywhere.
- I never considered dropping; not sure I really understand the question.
- I had no reason to drop it. The course was very informative and well organized.
- Building on one project for the bulk of the course made it feel like I was progressing toward a bigger goal, while consistently introducing new and progressively harder hurdles to go over. Having that larger project completed feels like an accomplishment in itself, as well as a "library" that I can look back at for future projects. Plus I want to graduate, so there's that
- The challenges that made me want to become a better programmer. Also, learning about REST and android was fun and something I looked forward to.
- I don't quit things. Also, i found your grading/ feedback helpful and it was easy to get back on track after feeling behind.
- I think everything we learned was practical. The projects helped me improve my development and testing skills. Also, I can now say I've made an Android app.
- I mentioned this in my midterm survey and I'll mention it again. This has been the most organized course I've had in the CS department at PSU. I remember feeling a wave of excitement after the first lecture that I hadn't felt since my first class with Karla when I was first learning C++. This has also been one of the most challenging classes I've been in due to the amount of material we go through in such a short amount of time, and yet I found myself enjoying the challenge (when I wasn't ill, that is -- this is a course where you cannot be out for a week because there is far too much material).
- I really enjoyed this course and learned a lot. I didn't consider dropping the course.
- It was mostly new material to me, and I enjoy how the class is taught. The few weeks with emphasis on pair- and mob- programming are also a nice break from traditional classes. I would argue that this class provides the closest real-world experience.
- The projects and the lectures made me stay in this course. They both were enjoyable and fun. I think all students should take this course because it really helps with developing one's programming skills in Java.
- It was extremely well organized and all materials were provided prior to the week they are assigned. The professor was constantly responding to questions, sharing insights and encouraging more participation and feedback. Great transparency, grade updates, feedback (when asked - due to large class size), quality assignments with room to go beyond the requirements.
- Learning a lot of good stuff, I enjoy the projects, and my grade isn't suffering.
- Various of experience on JAVA and also the programming skills
- The work is chellenging enough, but not with an incredibly steep learning curve, and I can clearly see the utility of the skills being taught. That, and this the last class I'm taking before I can graduate, so I would need a very good reason to drop at this point.
- The challenge. I knew enough "java" to get by, and coming from a lengthy C++ career, but really wanted to learn more about the intricacies of Java. While it touched on this a tad, it was more about tools and workflows that held my interest. And of course, the Android project. That was something I've been wanted to do for a long time, and never got around to it. As part of the course, I no longer had any excuses.
- I was determined to stay in this class no matter what. That's the honest truth. I know Java is used everywhere and I need to learn the fundamentals here.
- I want to be a better programmer and learning new things is a big part of that, so getting to learn more Java helps.
- I never considered leaving the course.
- I felt accomplished each week. Thinking about how much time was spent on those projects made me look back with a smile. Like, I did it.
- David's willingness to answer questions is huge!
- I felt I wasnt challenged in the way this class challenged me to produce solid code since CS202 and I truly crave this kind of work.
- Well-designed projects.
- The projects. I'm not good at going out and learning new things without some sort of exterior motivator, so I was pretty excitied to have the chance to work on a servlet and an android app.
- Android Programming!
- Learning Test Driven Development, working on continuous evolution of a single project.
- The content is important and directly relevant to what is being looked for in recent graduates. The unit testing knowledge has immediately been useful to me, because I recently started doing unit testing on a producting level w/ my internship.
- I feel like I got quite a bit of value espcially out of the second half of the course where I learned to work with web and android.
- I was having fun with the programming.
- It was interesting and I need CS credits
- Java is popular programming language. It is used to develop many large software in the world so that I want to learn more about it.
- There were so many challenges and work in this class, but I learned a lot. Also, the professor gave out chances if projects were submitted wrong or if there were issues. Therefore, the grading seemed reasonable and forgiving so I decided to stay. There seemed to have some room for error so that I didn't need to be too afraid to make mistakes so I could just put my focus on learning instead.
- Two things: First, I didn't have a lot of options. I needed an upper division CS elective and I was taking two other courses so scheduling needed to line up. Second, this class seemed extremely practical. Up until now I've been taking classes like AI and Intro to Quantum Computing, that are fun and challenging and buzzwordy but not likely to actually land me a job. On the other hand, half the job listings I've seen want 2+ years of Java experience, and now I know enough to BS that.
- I enjoyed learning more about Java and I need to finish this course to graduate.
- I thought the material was really fun and useful to learn. I've been in classes where I've questioned the importance of the material and this wasn't that class at all. I learned things that were directly applicable to what I want to work on and then got to actually work on those things. It was class that was challenging but a lot of fun
- If you had to remove one lecture from this course, which would itbe? Why?
- The Pair Programming lecture because I believe many students are familiar with how this works and its benefits.
- it might be some lecture content related to environment setup, I believe those can be done before class.
- The mobb programming lecture. I think this is only because its an online course. Mobb programming online does not really work very well.
- I wouldn't have removed any lecture from this course, but one structural change that I would have liked is to have two weeks for project 4 and project 5. As I am new to both web and android, to get to the starting point takes time.
- I don't have an answer to this.
- If it is remote then I am not sure pair and mob programming are that effective.
- Personally, I want to remove the android part, I know Java supports many famous android applications, but I have no interest in android applications. The android application has high level portability, so I prefer to spend time on my personal GUI stuff instead of android. As above, I learned that Unreal4 supports many items in the engine. People can directly use it. And people can spend time on building new items also, but there is one rule that cannot be broken. Unreal4 Engine has the basic rule when running the program, it is the real time. It always controls the programmers, I am wrong also because there are many other engines to make games. People can use other engines even built by themselves. I want to say android of java still has the disadvantages, the java has limitations like make the problems with the Android API, and we can see the Java needs mass code to build the android only because it with the risks of bugs and errors. Also, Java is powerful, but the use is to use more memory on the computer. Personally, I think android is not the best choice, and many programmers do not touch android in their whole life. I prefer to learn more knowledge that builds a personal application with GUI. It supports the contributed skills and also helps students to improve their code skill without the API that is already given. This is just my personal idea, only because I do not use android in the current situation, so I prefer to learn other knowledge, but for students who need the knowledge it should support a lot in their workplace.
- I think its perfect the way it is now.
- Remove the Web server and client project, then add one more project for android, because Java is not really used for web app now.
- If I had to remove one lecture it would be the Android content. I felt that I didn't get much out of it that would be useful outside of Android development. With the early projects we had the learning experience of test driven development, and with the REST project we had things like Mockito. However, with Android, we didn't get much outside of the Android framework itself.
- I would not remove any but would like you to add more lectures for deeper understanding of java development.
- I feel as though we only loosely worked with concepts pertaining to dependency injection and mocking. That said, I will have at least heard of those things next time they come up.
- If I had to remove one lecture from this course it would be the mob programming section. As I mentioned in my reflections that the "Mob programming would be effective in situations where people have the same levels of skill, and members in the team know each other, trust each other. Moreover, and have someone to be the leader who can make decisions. Mob programming would be ineffective in situations where people have the same knowledge set but have different levels of knowledge, and there is no trust has been build within the team." Mob programming might work if we are in the regular on-campus classroom, but I don't think it is effective in remote. I didn't gain a lot from it.
- With remote learning any lecture that does not deliver value can be back-burnered with the mute button, so I wouldn't seek to remove any lectures from this course. (Who would I be helping with that?) However, I would probably like to see some of the in-class noodling around w/ code replaced with something I could personally use--like (for example) a mini-lecture on "how to elicit requirements."
- I 'm not sure since each topic is very helpful
- Mob programming or pair programming - just personal preference. I don't do well with those types of exercises.
- Lecture? They were all helpful and informative. Seeing helps more than reading in some situations. If any, the lecture that half of it included helping people setup kind of dragged on. The slack helped me more in that situation.
- That would be like choosing my least favorite child to get rid of! :) I will say that the 4 hour lectures are hard to keep up with, and i could not watch in one go. The ones that were time stamped were very helpful.
- I wouldn't remove a lecture; I think they all provided valuable info.
- I wouldn't remove a lecture persay, but I would remove one of the mob and pairing exercises so that we have an extra lecture to go over more Java focused material. Again I mentioned this in the midterm survey but I think it would have been just as effective to have students find pairs via a slack channel and pair outside of class.
- I wouldn't. I think the lectures flowed nicely with the course. They all gave good context to the projects and overall understanding of the Java language.
- The one lecture where we had trouble setting up assignment 5. This is the obvious choice because it took a long time to troubleshoot, however, I know it was a one-off event. The video that was posted after the class was great and concise. As far as the other lectures, I honestly wouldn't remove any of them. They all have really good content.
- I wouldn't remove any lectures from this course. All lectures were quite beneficial to me. Even though I didn't get to attend all of the live lectures (due to time conflicts with another class), I was able to watch the recorded ones.
- In an 8 week course with 1 lecture a week, I would not recommend removing any more class time. This course would really be better in a 10 week term. If I had to remove a lecture, it would probably be one of the coding lectures in week 3-5 that comes before the pair/mob programming since there wasnt much material covered (most of the necessary matieral was in the recorded videos due prior to class) and was mostly project clarification questions and examples (very useful but can be done via slack, email, recorded videos). The pair and mob programming would have been great to do more of.
- Maybe dependency injection (mainly part 2). I found the in-class walkthroughs with mockito to be more helpful on understanding how to use it for Project 4. The Google Juice part is good to know, but it doesn't seem helpful for this class, especially because we don't do anything with it either.
- none
- I can't think of one.
- Hard to say, as this was already a condensed term because of summer, but if I had to, the Reflections and/or Injections. While enlightning, it didnt seem to pertain to the project work.
- I wouldn't remove one, but, I would move the full android lecture to the day the assignment 5 is assigned. A lot of my code is a bit funky because I played with fragments. I played with fragments because I tried to get ahead of the class, and played with them ahead of the lectures. One other thing I would say is, as a professor, please try to make any changes to your .sh and .cmd files ahead of time, and don't change them after the class starts. I tried to get ahead and created my proejcts and worked on them, but they later became different than what was tested for because the maven files were changed.
- This is pretty hard, but I guess I would lean towards the android stuff (despite it being interesting), because it's the least "essential" whereas removing some of the previous things might leave a bigger hole in Java knowledge.
- I would consolidate the two mob programming sessions into one session to fit in either more professor & student mob programming, or add more lecture material.
- None, the android and servlet ones were especially helpful to me.
- They all appear very relevant. The most I would do is try and shrink some of the lectures to try to fit in newer topics. Some of the material is a little dated and could use a refresher.
- I honestly don't think I could pick one. I think they were all very infomative and important to have.
- The Mod and pair programming lectures could be removed and instead replaced with a Programming assignment that is entirely done with pair or mob programming. I think if this was done after the first assignment it would be an incredible learning experience to see how others use Intellij and do Java development. I liked the pair programming allot I just think it should be done more instead of a single lecture!
- Mob programming? It is similar to pair programming and we have limited time to organize a group in class.
- I'm going to be frank, my memory is questionable and I cannot remember any of the lectures individually. I will say that I found the lectures where you went over the project/did a demo project in that style very helpful, since I learn best from watching and copying.
- I would remove pair programming since mob programming gives about the same kind of experience.
- I think all lecture are required as per assignment. Based on course structure I stroglgly admire to keep all the lecture.
- I guess, the lecture on dependency injection, I didn't really get much from that lecture and I did not think it was relevant for the projects.
- The android studio set-up lecture, but that's only because it was pre-recorded.
- I don't have a specific lecture in mind. However, it would be better if people's environment problems were solved outside of class (over slack and during office hours). If something is fixed in office hours, it could be shared over slack as well. This would take some stress off of you and would encourage people to problem solve for themselves. More importantly, it would allow the lectures to always focus on material.
- All of the lectures felt useful, but I did kind of lose focus during some of the Q&A sessions.
- Probably one where we started on a new project while another one was still due
- Every lecture in this course is necessary and helpful so I don't want to remove any lectures.
- If I had to remove one lecture, then I might remove mob programming. Maybe I am a little biased since I didn't have a very good experience with it due to poor internet connection that day. However, I do feel that mob programming is similar to pair programming, so maybe pair programming and mob programming can be done in the same lecture.
- I wouldn't remove any of the lectures. I might combine the second and third projects though. The projects were too close together.
- This is a difficult question because the course is so short and we had to cover so much ground that they seem all nessary. Maybe I would spend less lecture time going over the students expecation of the course. I feel like all of that information could have been defined in a survey.
- Hmmmm I think maybe the functional programming lecture. Not that I don't think learning that isn't useful or important but I honestly forgot to watch that lecture and I feel like it didn't impact me much in the course.