536 Teacher Placement Planning: When managing staff resources, educational leaders should seek to assign teachers and staff to roles and responsibilities that match their professional skills, abilities, and interests in a way that will be best for student success.

For this assignment, take on the role of school principal at an elementary. You have several projected vacancies in various grades and subjects.

In 425-words, use either the “Antelope Elementary School Hiring Scenario” or the Antelope High School Hiring Scenario” to decide if you will fill these positions from your current faculty or accept outside applications to fill these projected vacancies.

Address the following as a part of your planning, rationalizing your choices specific to:

· District policy and/or collective bargaining procedures, seniority requirements, union or professional association mandates

· Teacher screening procedures

· How well the teacher collaborates with staff and community members to maintain a sense of involvement and trust

· How their actions align with the ethical principles of compassion and concern for the common good

APA Style Guide. Rubric:

20 District Policy Planning comprehensively accounts for district policy and/or collective bargaining procedures, seniority requirements, and union or professional association mandates.

20 Screening Procedures Planning and rationalizing specifically includes teacher screening procedures.

20 Collaboration Planning and rationalizing insightfully addresses how well the teacher collaborates with staff and community members to maintain a sense of involvement and trust.

20 Ethical Principles Planning and rationalizing thoroughly addresses how their actions align with the ethical principles of compassion and concern for the common good.

 

 

EAD-536-AntelopeElementaryCurrentStaffList.docx

Antelope Elementary School Hiring Scenario

You are the principal of Antelope Elementary, the STEM magnate for your district. It has 60% open enrollment, and some parents seem to believe it is a private school. Antelope Elementary prides itself on its project-based curriculum with STEM woven throughout and having the highest test scores in the 20-school district. It is February and the district has just communicated to you the allocation of three teachers per grade level.

Your task for Antelope Elementary is to devise a strategy for hiring certified staff to fill your allocation. Take into account the descriptions of the entire staff and the current PLC makeups in the table below. Teachers who are leaving Antelope Elementary at the end of the school year are shaded. Describe your ideal candidate for each position and explain what your strategy for hiring will be.

Kindergarten Ideal Candidate
Bobbie New	Bobbie is a third-year teacher who works well independently, but struggles working in a team setting. She is very dedicated to her students’ success. She is praised for communicating with her student’s families with ease.
Tracy Cobbler	Tracy is a veteran teacher with 20 years of experience in the classroom. She recently transferred from another school and is the team lead. She struggles with the technology staff uses daily, but is willing to ask for help.
Amanda Apple	Amanda is also a third-year teacher. She is excellent at building rapport with her students.
First Grade
Angel Ekko	Angel is a veteran teacher with 15 years of experience. She is a life-long learner and her students consistently achieve the highest Dibels scores in first grade. She is also the team lead and is respected by all staff.
Laura Pope	Laura is a veteran teacher with 20 years of experience. She formerly was the instructional coach at Antelope. If her students earn low summative test scores, she immediately becomes defensive. She is known to argue constantly with the team lead and is generally disliked on campus. Her sister teaches seventh grade science.
Sally Hall	Sally is a third year teacher. She has great high achievement in the classroom, but has a poor attitude. She does not get along with Laura.
Second Grade
Holly Hoon	Holly and Nikki have similar personalities. Both are great at technology integration and science. They have worked together for three years and are friends outside of school. Holly is the lead, with 10 years of experience in the classroom, Nikki has 7.
Nikki Doe
Sally South	Sally is new to the second grade team this year and is a fifth year teacher. She moved from third grade the previous year to be mentored by Holly and Nikki. You are not seeing much improvement in her teaching performance, and her team members are becoming frustrated.
Third Grade
Kim Wallace	Kim is a strong teacher who has just returned from teaching abroad. She sponsors the STEM Club and is the lead of the third grade team. She is particularly instructionally strong in the areas of science and math. She has had some recent personal troubles that have had an effect on her promptness.
Siri Stills	Siri is new to the team and is a third-year teacher. She has a strong partnership with Kim and is genuinely excited to do the best for her students. It has been noted that her excitement has prevented her from keeping to the assigned academic schedule from time to time.
Mika Pepper	Mika was hired this year. She struggles with classroom management and has missed a day of school per week this year.
Fourth Grade
Dede Miller	Dede was previously the fourth grade team lead, but asked to be relieved of the title this year. She is very willing to do what is asked, but rubs some the wrong way with her brash attitude.
Pablo Sanchez	Pablo is a second-year teacher. He is like a sponge and implements strategies to meet the specific needs of his students. His students achieved the highest academic performance for the grade last year.
Kim Mighty	Kim sponsors multiple clubs and is a strong teacher. She truly understands STEM concepts, but does not collaborate well with others. She is the team lead.
Fifth Grade
Sue Lauder	Sue is the best STEM teacher on campus. She integrates technology flawlessly and is always willing to help others.
Jacque Palm	Jacque has been at Antelope since the school opened and has great rapport with students as well as parents. When staff members want answers, they go to her. She does struggle with imbedding STEM curriculum throughout the subjects.
Cody Woo	Cody had the best English scores in the district this year. He is the PLC lead and is a servant leader. He has just been offered a job at the high school where his daughter attends.
Sixth Grade
Claudia Sal	Claudia is one of the best math teachers on campus. She is engaged with the community, but is known to lose her patience at times. Her temper has led fellow teachers to describe her as too aggressive and even as a bully. She is the sixth grade team lead.
Justin Hope	Justin is new to the sixth grade team. He teaches science and incorporates hands-on learning every day. He is easy going and adaptive.
Helen Back	Helen is a great teacher and is particularly strong in ELA. She is known as the cheerleader of the team and has confided in you that Claudia’s temper is hard to combat.
Seventh Grade
Caren Pope	Caren is Laura Pope’s sister. She is a dynamic teacher and implements the school’s STEM vision in an innovative way. She constantly does hands-on science and breaks math down with skill. She is a favorite of many parents. She is extremely loyal to her sister and defends her always. Caren is the team lead for the seventh grade.
Ellen Garcia	Ellen is an excellent social studies teacher and has been at Antelope for two years. She is known for her stubbornness and has high expectations for her students. She will be out this year frequently due to health issues.
Jose Ruiz	Jose is the math teacher. He completes all tasks asked of him, but with little confidence. Students enjoy his class. He has not developed an integrated approach for math with the STEM initiative.
Eighth Grade
Marco Garcia	Marco is a student favorite who would do anything for the school. He teaches English and social studies. He often listens to advice on how to become stronger instructionally, but seldom uses these practices in the classroom. He is the team lead.
Kara Lara	Kara is a math teacher, who does not have high expectations for her students. She is very dependent on Jen. Kara has the lowest math scores in the school. She plans to retire either next year or the year after.
Jen DeMarco	Jen is the team lead and has been for years. She is a great teacher, but is easily distracted. It is widely known that she does not like you.
SPED
Scott DuBoy	Scott is the special education teacher for grades K-3. He is overwhelmed and struggles to meet the needs of his students. He is on an improvement plan, and will be with Antelope for at least one more year.
Tatum Ole	Tatum teaches students in grades 6-8. She is an excellent mentor to Jill. She is your SPED lead and is a very strong leader, keeping the SPED team positive. She will be moving to New York next year.
Jill Nolan	Jill is a first-year teacher mentored by Tatum. She teaches grades 4-6 and is highly motivated. She has many great instructional days, but needs support in these first years of teaching.

 

NOTE: You will need the description of the Antelope Elementary school staff for future assignments.

SMP5: Scheduler with Signals

============================

This MP is a variation of SMP4.

In the last MP, we built a simulated OS process scheduler. The scheduler can

hold only a certain number of processes (workers) at one time. Once the process

has been accepted into the scheduler, the scheduler decides in what order the

processes execute. We implemented two scheduling algorithms: FIFO and Round

Robin.

In this MP, we are to simulate a time-sharing system by using signals and

timers. We will only implement the Round Robin algorithm. Instead of using

iterations to model the concept of “time slices” (as in the last MP), we use

interval timers.  The scheduler is installed with an interval timer. The timer

starts ticking when the scheduler picks a thread to use the CPU which in turn

signals the thread when its time slice is finished thus allowing the scheduler

to pick another thread and so on. When a thread has completely finished its work

it leaves the scheduler to allow a waiting thread to enter. Please note that in

this MP, only the timer and scheduler send signals. The threads passively handle

the signals without signaling back to the scheduler.

The program takes a number of arguments. Arg1 determines the number of jobs

(threads in our implementation) created; arg2 specifies the queue size of the

scheduler. Arg3 through argN gives the duration (the required time slices to

complete a job) of each job. Hence if we create 2 jobs, we should supply arg3

and arg4 for the required duration. You can assume that the autograder will

always supply the correct number of arguments and hence you do not have to

detect invalid input.

Here is an example of program output, once the program is complete:

% scheduler 3 2 3 2 3

Main: running 3 workers with queue size 2 for quanta:

3 2 3

Main: detaching worker thread 3075926960.

Main: detaching worker thread 3065437104.

Main: detaching worker thread 3054947248.

Main: waiting for scheduler 3086416816.

Scheduler: waiting for workers.

Thread 3075926960: in scheduler queue.

Thread 3075926960: suspending.

Thread 3065437104: in scheduler queue.

Thread 3065437104: suspending.

Scheduler: scheduling.

Scheduler: resuming 3075926960.

Thread 3075926960: resuming.

Scheduler: suspending 3075926960.

Scheduler: scheduling.

Scheduler: resuming 3065437104.

Thread 3065437104: resuming.

Thread 3075926960: suspending.

Scheduler: suspending 3065437104.

Scheduler: scheduling.

Scheduler: resuming 3075926960.

Thread 3075926960: resuming.

Thread 3065437104: suspending.

Scheduler: suspending 3075926960.

Scheduler: scheduling.

Scheduler: resuming 3065437104.

Thread 3065437104: resuming.

Thread 3075926960: suspending.

Scheduler: suspending 3065437104.

Thread 3065437104: leaving scheduler queue.

Scheduler: scheduling.

Scheduler: resuming 3075926960.

Thread 3075926960: resuming.

Thread 3065437104: terminating.

Thread 3054947248: in scheduler queue.

Thread 3054947248: suspending.

Scheduler: suspending 3075926960.

Thread 3075926960: leaving scheduler queue.

Scheduler: scheduling.

Scheduler: resuming 3054947248.

Thread 3054947248: resuming.

Thread 3075926960: terminating.

Scheduler: suspending 3054947248.

Scheduler: scheduling.

Scheduler: resuming 3054947248.

Thread 3054947248: suspending.

Thread 3054947248: resuming.

Scheduler: suspending 3054947248.

Scheduler: scheduling.

Scheduler: resuming 3054947248.

Thread 3054947248: suspending.

Thread 3054947248: resuming.

Scheduler: suspending 3054947248.

Thread 3054947248: leaving scheduler queue.

Thread 3054947248: terminating.

The total wait time is 12.062254 seconds.

The total run time is 7.958618 seconds.

The average wait time is 4.020751 seconds.

The average run time is 2.652873 seconds.

The goal of this MP is to help you understand (1) how signals and timers work,

and (2) how to evaluate the performance of your program. You will first

implement the time-sharing system using timers and signals. Then, you will

evaluate the overall performance of your program by keeping track of how long

each thread is idle, running, etc.

The program will use these four signals:

SIGALRM: sent by the timer to the scheduler, to indicate another time

quantum has passed.

SIGUSR1: sent by the scheduler to a worker, to tell it to suspend.

SIGUSR2: sent by the scheduler to a suspended worker, to tell it to resume.

SIGTERM: sent by the scheduler to a worker, to tell it to cancel.

You will need to set up the appropriate handlers and masks for these signals.

You will use these functions:

clock_gettime

pthread_sigmask

pthread_kill

sigaction

sigaddset

sigemptyset

sigwait

timer_settime

timer_create

Also, make sure you understand how the POSIX:TMR interval timer works.

There are two ways you can test your code.  You can run the built-in grading

tests by running “scheduler -test -f0 rr”.  This runs 5 tests, each of which can

be run individually.  You can also test you program with specific parameters by

running “scheduler -test gen …” where the ellipsis contains the parameters you

would pass to scheduler.

Programming

===========

Part I: Modify the scheduler code (scheduler.c)

———————————————–

We use the scheduler thread to setup the timer and handle the scheduling for the

system.  The scheduler handles the SIGALRM events that come from the timer, and

sends out signals to the worker threads.

Step 1.

Modify the code in init_sched_queue() function in scheduler.c to initialize the

scheduler with a POSIX:TMR interval timer. Use CLOCK_REALTIME in timer_create().

The timer will be stored in the global variable “timer”, which will be started

in scheduler_run() (see Step 4 below).

Step 2.

Implement setup_sig_handlers().  Use sigaction() to install signal handlers for

SIGALRM, SIGUSR1, and SIGTERM.  SIGALRM should trigger timer_handler(), SIGUSR1

should trigger suspend_thread(), and SIGTERM should trigger cancel_thread().

Notice no handler is installed for SIGUSR2; this signal will be handled

differently, in step 8.

Step 3.

In the scheduler_run() function, start the timer.  Use timer_settime().  The

time quantum (1 second) is given in scheduler.h.  The timer should go off

repeatedly at regular intervals defined by the timer quantum.

In Round-Robin, whenever the timer goes off, the scheduler suspends the

currently running thread, and tells the next thread to resume its operations

using signals. These steps are listed in timer_handler(), which is called every

time the timer goes off.  In this implementation, the timer handler makes use of

suspend_worker() and resume_worker() to accomplush these steps.

Step 4.

Complete the suspend_worker() function.  First, update the info->quanta value.

This is the number of quanta that remain for this thread to execute.  It is

initialized to the value passed on the command line, and decreases as the thread

executes.  If there is any more work for this worker to do, send it a signal to

suspend, and update the scheduler queue.  Otherwise, cancel the thread.

Step 5.

Complete the cancel_worker() function by sending the appropriate signal to the

thread, telling it to kill itself.

Step 6.

Complete the resume_worker() function by sending the appropriate signal to the

thread, telling it to resume execution.

Part II: Modify the worker code (worker.c)

——————————————

In this section, you will modify the worker code to correctly handle the signals

from the scheduler that you implemented in the previous section.

You need to modify the thread functions so that it immediately suspends the

thread, waiting for a resume signal from the scheduler. You will need to use

sigwait() to force the thread to suspend itself and wait for a resume signal.

You need also to implement a signal handler in worker.c to catch and handle the

suspend signals.

Step 7.

Modify start_worker() to (1) block SIGUSR2 and SIGALRM, and (2) unblock SIGUSR1

and SIGTERM.

Step 8.

Implement suspend_thread(), the handler for the SIGUSR1 signal.  The

thread should block until it receives a resume (SIGUSR2) signal.

Part III: Modify the evaluation code (scheduler.c)

————————————————–

This program keeps track of run time, and wait time.  Each thread saves these

two values regarding its own execution in its thread_info_t.  Tracking these

values requires also knowing the last time the thread suspended or resumed.

Therefore, these two values are also kept in thread_info_t.  See scheduler.h.

In this section, you will implement the functions that calculate run time and

wait time.  All code that does this will be in scheduler.c.  When the program

is done, it will collect all these values, and print out the total and average

wait time and run time.  For your convenience, you are given a function

time_difference() to compute the difference between two times in microseconds.

Step 9.

Modify create_workers() to initialize the various time variables.

Step 10.

Implement update_run_time().  This is called by suspend_worker().

Step 11.

Implement update_wait_time().  This is called by resume_worker().

Questions

==========

Question 1.

Why do we block SIGUSR2 and SIGALRM in worker.c?  Why do we unblock SIGUSR1 and

SIGTERM in worker.c?

Question 2.

We use sigwait() and sigaction() in our code. Explain the difference between the

two. (Please explain from the aspect of thread behavior rather than syntax).

Question 3.

When we use POSIX:TMR interval timer, we are using relative time. What is the

alternative? Explain the difference between the two.

Question 4.

Look at start_worker() in worker.c, a worker thread is executing within an

infinite loop at the end. When does a worker thread terminate?

Question 5.

When does the scheduler finish?  Why does it not exit when the scheduler queue

is empty?

Question 6.

After a thread is scheduled to run, is it still in the sched_queue? When is it

removed from the head of the queue? When is it removed from the queue completely?

Question 7.

We’ve removed all other condition variables in SMP4, and replaced them with a

timer and signals. Why do we still use the semaphore queue_sem?

Question 8.

What’s the purpose of the global variable “completed” in scheduler.c? Why do we

compare “completed” with thread_count before we wait_for_queue() in

next_worker()?

Question 9.

We only implemented Round Robin in this SMP. If we want to implement a FIFO

scheduling algorithm and keep the modification as minimum, which function in

scheduler.c is the one that you should modify? Briefly describe how you would

modify this function.

Question 10.

In this implementation, the scheduler only changes threads when the time quantum

expires.  Briefly explain how you would use an additional signal to allow the

scheduler to change threads in the middle of a time quantum.  In what situations