RxJS best practices in Angular
This article is all about the do’s and don’ts when it comes to writing reactive applications with RxJS in Angular applications. The best practices described in this article are based on personal experiences and can be assumed as personal opinions.
The topics we will tackle in this article are:
- Learning how to think reactive
- Pipeable operators
- ASCII marble diagrams
- Using pure functions
- Avoiding memory leaks
- Avoiding nested subscribes
- Avoiding manual subscribes in Angular
- Don’t pass streams to components directly
- Don’t pass streams to services
- Sharing subscriptions
- When to use Subjects
- Clean-code practices
- Angular embraces RxJS
Note:
We will refer to observables as streams in this article.
Since the streams in this article use the $
-suffix, a short explanation.
First of all, there is a lot of debate about the $
-suffix but I believe this should be a personal preference.
The reason why I prefer to use it, is because I find it very easy to separate streams from regular objects.
That being said, I would not consider it a best practice, just a personal choice.
Learning how to think reactive
Reactive programming is completely different than imperative programming. It requires us to make a certain mind switch. This mind switch is rather important if we want to benefit from RxJS completely. We want to stop thinking in specific actions and we want to start thinking in streams. It requires us to forget a part of practices that we already know (at least for a moment). In this article we can find some tips and practical examples on how to start thinking reactive in RxJS.
Pipeable operators
The first best practice is the use of pipeable operators. The operators being used in this article are pipeable. Since version 5.5 RxJS has introduced these so called pipeable operators which are easier to import than patch operators, and also have treeshaking advantages. More information about pipeable operators can be found here and here.
This example illustrates the difference between doing it the old way and the new way.
// BAD: This is the old way and should be avoided (patch operators)
// as we can see the operators (filter, map) are part of the
// Observable prototype
import 'rxjs/add/operator/filter';
import 'rxjs/add/operator/map';
const new$ = Observable.interval$
.filter(v => v % 2 === 0)
.map(v => v * 2);
// GOOD: This is the new and improved way (lettable operators)
// we just use the pipe operator where we pass operators that
// we can import from 'rxjs/operators'
import {filter, map} from 'rxjs/operators';
const new$ = interval$
.pipe(
filter(v => v % 2 === 0),
map(v => v *2)
)
ASCII marble diagrams
Some developers tend to say: “Great code should be self-explanatory, writing documentation is something that we might want to avoid.” In some cases I would agree with that statement, but for complex RxJS code we might want to reconsider. Streams can become complex in the following scenarios:
- When we take the lifecycle of streams into account, (how long do they live? when do they start living? what destroys them?)
- When we start combining streams (every stream has a different lifecycle remember?)
- When we subscribe multiple times or even subscribe after a while, or even never subscribe to them
marble diagrams are a cool way of visualising streams but it’s hard to put those marble-diagrams in our code right?! There is an ASCII variant of these marble-diagrams that we can use to describe and document our complex streams and how they interact with each other.
ASCII diagrams have more advantages then just documenting:
- It gives us a graphic thinking model
- It becomes easy to review someones code and validate to see if it really does what it’s supposed to be doing
- Great to draw on a whiteboard before we start coding
- You can type them in your IDE or editor before you actually start coding. (An easy way to trick your mind into thinking reactively)
- We can use them to write unit tests as well: Checkout this awesome article
The concepts behind ASCII marble documentation are quite simple. Take this easy example for instance:
// ---a--b--c--d---e---...
// ---a--b--c--d---e|
// ---a--b--c--d---e#
// ---a--b-^-c--d---e
-
(stands for a time frame)a-z
(are the values that are next’ed in the stream)|
(indicates that the stream has completed)...
(indicates that the stream will keep on living)#
(indicates that an error occurred)^
(indicates where we start subscribing (only for hot streams)
Perhaps it’s time to check a real example and how we might document it:
const interval$ = interval(1000) // 0--1--2--3--4--5--6...
const new$ = interval$
.pipe(
skip(1), // ---1--2--3--4--5--6...
take(5), // ---1--2--3--4--5|
filter(v => v % 2 === 0), // ------2-----4---|
map(v => v + 1) // ------3-----5---|
)
Take a minute to let this sink into your brain, because this might be THE WAY of making a complex code snippets readable for anyone.
When we take a look at this diagram, it’s fairly easy to comprehend what happens, and how every operator affects the new$
stream we can see above. There is no “one way of doing things” when it comes to writing ASCII marble-diagrams. You can put them where and how you want.
As we want to do for all other documentation: keep it up to date!
Using pure functions
RxJS follows the concepts of functional reactive programming which basically means that we will use pure functions to create our reactive flow. A function is pure when:
- It doesn’t mutate anything
- It will always return the same value based on the same parameters
- It doesn’t have any side effects. It can’t mutate state outside of the function
In the beginning it might seem pragmatic to use side effects, but that mostly means we aren’t fully thinking reactively. Therefore avoid side effects at much as possible.
Avoiding memory leaks
To consume a stream we need to subscribe to that stream. When we subscribe to that stream a subscription will be created. That subscription will keep on living until the stream is completed or until we unsubscribe manually from that stream. Managing subscriptions is very important and in a number of cases we will have to manually unsubscribe an existing subscription to avoid memory leaks. Take this example for instance:
class AppComponent implements OnInit {
ngOnInit() {
// The following stream will produce values every second
// 0--1--2--3--4--5--6--...
const interval$ = interval(1000);
// Even when this component gets destroyed,
// the stream will keep producing values...
// This means the console will keep on logging
// This is a classic example of a memory-leak
const subscription = interval$.subscribe(r => console.log(r));
}
}
To remove the memory-leak in this component we can keep track of the subscriptions by taking advantage of the ngOnDestroy()
lifecycle hook of Angular:
class AppComponent implements OnInit, OnDestroy {
subscriptions = [];
ngOnInit() {
const interval$ = interval(1000);
const subscription = interval$.subscribe(r => console.log(r));
// manually keep track of the subscriptions in a subscription array
this.subscriptions.push(subscription);
}
ngOnDestroy() {
// when the component get's destroyed, unsubscribe all the subscriptions
this.subscriptions.forEach(sub => sub.unsubscribe());
}
}
However, when we are using a bunch of subscriptions, it can become quite dirty. Before, we talked about the fact that a subscription will live until we manually unsubscribe (like we just did in the snippet above), but also until the stream gets completed. A cool way to handle this issue is to use a Subject that we next in the ngOnDestroy()
lifecycle hook of Angular:
class AppComponent implements OnInit, OnDestroy {
destroy$ = new Subject();
ngOnInit() {
// interval$: 0--1--2--3--4--5--6--...
// destroy$: -------------true|
// result: 0--1--2--3--4|
const interval$ = interval(1000);
interval$
// let the interval$ stream live
// until the destroy$ Subject gets a value
.pipe(takeUntil(this.destroy$))
.subscribe(r => console.log(r));
}
ngOnDestroy() {
// when the component get's destroyed, pass something to the
// destroy$ Subject
this.destroy$.next(true);
}
}
Avoiding nested subscribes
Nesting subscribes is something that needs to be avoided as much as possible. It makes the code unreadable, complex, and introduces side effects. It basically forces you to NOT think reactively. Take this Angular example for instance:
class AppComponent {
user: User;
constructor(
private route: ActivatedRoute,
private userService: UserService)
{
// when the params of the route changes,
// we want to fetch the user and set the user property
//
// VERY BAD: nesting subscribes is ugly and takes away
// the control over a stream
this.route.params
.pipe(map(v => v.id))
.subscribe(id =>
this.userService.fetchById(id)
.subscribe(user => this.user = user))
}
}
The previous implementation is considered a bad-practice. It’s recommended to use higher-order streams like mergeMap
or switchMap
. Let’s have a look at this example:
class AppComponent {
user: User;
constructor(
private route: ActivatedRoute,
private userService: UserService)
{
// when the params of the route changes,
// we want to fetch the user and set the user property
//
// GOOD: we have created a single subscribe which makes
// the flow way easier and gives us the control we need
this.route.params
.pipe(
map(v => v.id),
switchMap(id => this.userService.fetchById(id))
)
.subscribe(user => this.user = user)
}
}
Avoiding manual subscribes in Angular
To consume a stream we need to subscribe that stream, that’s simply how observables work. But what if a component needs values from 5 different streams… Would that mean, that we want to subscribe to all of these streams and manually map all the values to unique properties, just to make it work? That would suck, right?!
Angular has this super cool feature called the async pipe
. It’s used to consume streams directly in the template
The async pipe does 3 things for us:
- It subscribes to the stream and passes the value to a component
- It unsubscribes automatically when the component gets destroyed (removes a lot of unsubscribe logic)
- Triggers change detection automatically
This means we don’t have to manually subscribe nor unsubscribe anymore. Which cleans up the code a lot. Let’s have a look at the cleaned up previous example:
@Component({
...
template: `
<user-detail [user]="user$|async"></user-detail>
`
})
class AppComponent {
// expose a user$ stream that will be
// subscribed in the template with the async pipe
user$ = this.route.params.pipe(
map(v => v.id),
switchMap(id => this.userService.fetchById(id))
);
constructor(
private route: ActivatedRoute,
private userService: UserService) {
}
}
If you are into React, I’ve created this lib called react-rx-connect that would solve this problem. It binds the streams to the state, and unsubscribes from them when the component gets destroyed.
Don’t pass streams to components directly
One of the most important aspects of software architecture might be the concept of decoupling pieces of code. Therefore we could consider passing streams to child components as a bad practice because it creates a very tight link between the parent component and the child component. They are no longer decoupled since subscriptions in the child component might trigger actions in the parent component. We never want the child component to be responsible of initiating data calls right?! That’s the task of the smart component.  A component should always receive an object or value and should not even care if that object or value comes from a stream or not.
// BAD
// app.component.ts
@Component({
selector: 'app',
template: `
<!--
BAD: The users$ steram is passed
to user-detail directly as a stream
-->
<user-detail [user$]="user$"></user-detail>
`
})
class AppComponent {
// this http call will get called when the
// user-detail component subscribes to users$
// We don't want that
users$ = this.http.get(...);
...
}
// user-detail.component.ts
@Component({
selector: 'user-detail',
template: `
`
})
class UserDetailComponent implements OnInit {
@Input() user$: Observable<User>;
user: User;
ngOnInit(){
// WHOOPS! This child component subscribes to the stream
// of the parent component which will do an automatic XHR call
// because Angular HTTP returns a cold stream
this.user$.subscribe(u => this.user = u);
}
}
It would be better to handle the subscription in the parent component itself:
// GOOD
// app.component.ts
@Component({
selector: 'app',
template: `
<user-detail [user]="user$|async"></user-detail>
`
})
class AppComponent implements OnInit {
users$: Observable<User[]> = this.http.get(...);
user: User;
ngOnInit(){
// the app component (smart) subscribes to the user$ which will
// do an XHR call here
this.users$ = this.http.get(...);
}
...
}
// user-detail.component.ts
@Component({
selector: 'user-detail',
template: `
`
})
class UserDetailComponent {
// This component doesn't even know that we are using RxJS which
// results in better decoupling
@Input() user: User;
}
The responsibility of the component is clear. The user-detail is meant to be dumb and is completely decoupled from its parent.
There are however situations where we would like to create a stream from an input. In that case we could take a look at this library: ngx-reactivetoolkit
Don’t pass streams to services
Although, it might seem like a pragmatic solution to pass streams directly to services, it could be seen as a bad practice if we consider the decoupling again. By passing a stream to a service we don’t know what’s going to happen to it. The stream could be subscribed to, or even combined with another stream that has a longer lifecycle, that could eventually determine the state of our application. Subscriptions might trigger unwanted behavior. And after all, services don’t care that your components are using streams. Take this example for instance:
// BAD
// app.component.ts
class AppComponent {
users$ = this.http.get(...)
filteredusers$ = this.fooService
.filterUsers(this.users$); // Passing stream directly: BAD
...
}
// foo.service.ts
class FooService {
// return a stream based on a stream
// BAD! because we don't know what will happen here
filterUsers(users$: Observable<User[]>): Observable<User[]> {
return users$.pipe(
map(users => users.filter(user => user.age >= 18))
}
}
It would be better to use higher order streams for these situations.
Use switchMap
over mergeMap
if possible, since it will unsubscribe the previous stream.
The following example is better since all the RxJS logic is centralized in one place where the subscribing and unsubscribing happens: The smart component.
// GOOD
// app.component.ts
class AppComponent {
users$ = this.http.get(...)
filteredusers$ = this.users$
.pipe(switchMap(users => this.fooService.filterUsers(users)));
...
}
// foo.service.ts
class FooService {
// this is way cleaner: this service doesn't even know
// about streams now
filterUsers(users: User[]): User[] {
return users.filter(user => user.age >= 18);
}
}
Sharing subscriptions
Since most streams are cold by default, every subscription will trigger the producer of these streams.
The execution of the producer logic on every subscription, might not be what we want if we have multiple subscriptions.
Eg. Subscribing to Angular its http.get()
multiple times will actually perform multiple xhr calls.
The following example will trigger the xhr call twice because numberOfUsers$
depends on users$
.
@Component({
selector: 'app',
template: `
Number of users: {{numberOfUsers$|async}}
<users-grid [users]="users$|async"></users-grid>
`
})
// BAD
class AppComponent {
users$ = this.http.get(...)
// the subscription on this stream will execute the xhr call again
numberOfUsers$ = this.users$.pipe(map(v => v.length);
}
In those cases we might want to share the subscriptions. The following example uses the share()
operator:
@Component({
selector: 'app',
template: `
Number of users: {{numberOfUsers$|async}}
<users-grid [users]="users$|async"></users-grid>
`
})
// GOOD
class AppComponent {
users$ = this.http.get(...).pipe(share());
// the subscription on this stream will execute the xhr call again
numberOfUsers$ = this.users$.pipe(map(v => v.length);
}
Sharing a stream makes it hot. This means that if we subscribe after the value is produced, we will miss that value.
In that case we might want to use shareReplay(1)
instead of share()
. This will keep the last value in memory for us.
It’s a common mistake to share everything.
Angular also provides a great alternative that can reduce the sharing of streams to a minimum by using the async as else
syntax..
Personally I would consider the use of this feature as a best practice.
The following example reduces the number of streams, the number of subscriptions and gives us an easy way to show a loading indicator.
@Component({
selector: 'app',
template: `
<div *ngIf="users$|async as users; else loading">
Number of users:
<users-grid [users]="users"></users-grid>
</div>
<ng-template #loading>Loading...</ng-template>
`
})
class AppComponent {
// This stream will only subscribed to once
users$ = this.http.get(...);
}
When to use Subjects
A Subject is both a hot observable and an observer at the same time. This gives us the opportunity to next values into the stream ourselves. Subjects tend to be overused by people that didn’t make the mind switch towards reactive programming yet.
Only use them when really needed, for instance it’s ok to use Subjects in the following scenarios:
When mocking streams in tests
const fetchAll$ = new Subject(); // use a Subject as a mock
usersServiceMock.fetchAll.mockReturnValue(fetchAll$);
fetchAll$.next(fakeUser);
When we want to create streams from outputs in Angular
@Component({
...
template: `
<some-component (search)="search$.next($event)"></some-component>
`
})
class AppComponent {
search$ = new Subject(); // ----t-----te-----ter----term...
}
When handling circular references
I’m not going to dive in this to deep, but Dominic Elm does an awesome job explaining this in this great article
For most other cases an operator or Observable.create might be enough.
Note:
A BehaviorSubject is commonly used because it has a getValue()
function. That would also be considered a bad practice.
When we are trying to fetch a specific value it usually means we are not thinking reactive.
Clean code practices
Consistent code indentation and formatting can improve the readability of complex streams:
- Align operators below each other
foo$.pipe(
map(...)
filter(...)
tap(...)
)
- Extract into different streams when it becomes unreadable
- Put complexer functionality in private methods (make the reactive flow clear)
- Avoid the use of brackets for readability, that’s personal preference.
Angular embraces RxJS
We already saw a glimpse of why Angular is a framework that really embraces the use of RxJS. Therefore it’s recommended to use the functionality that Angular provides.
- The
ActivatedRoute
has exposes a params stream. - The Http and HttpClient both return streams
- The
Form
andFormControl
both have avalueChanges
property that returns a stream - The async pipe is an awesome feature that really helps us to use the streams in our templates
- Using the
ngOnInit()
lifecycle function to initialize streams can help us for mocking purposes
Conclusion
Still here? Awesome! We learned a lot! If this article interests you, you might want to check out the “Advanced RxJS in Angular workshop” from Strongbrew, where me and Kwinten Pisman teach how to use advanced RxJS in real Angular applications.


This week has slowed down a little bit. It is more a research week,I wasn’t able to do what I thought I would do, like working on hoodie
because I just realized I might have even better ways to achieve my goals.
Work
No PR was submitted to the tyk
gateway this week, however I have been onto some cool stuff that might prove useful to the gateway someday.
So, I was researching on a benchmarking solution for the gateway. The main criteria of the solution was
- configurable (should be a ble to rune different parameters like environments/configurations etc)
- simple to reason about and implement
- detect regressions on new changes commits/pr’s
I have made quiet a progress on this, probably I might have a prototype by next week. I can’t talk much about it because its still experimental and lots of moving pieces.
Private
I took a look on hoodie
, especially the unicode
module which is a port the go unicode
package. I think it is bloated, because it duplicates what zig already offers on the standard library and to some extent differs for instance in zig a code point is u32
but in hoodie
it is 132
.
I initially ported Nim’s unicode
module. I was successful but realized it was so basic and lacked lots unicode related features, for instance its range tables are only limited to UnicodeData.txt
file.
Then I remember reading about quickjs and its full unicode library written in C. So I took the liberty of studying what these people do with unicode. Also I have actually been reading the specification too to get more familiar with unicode so I will understand implementation.
My goal now is to port quickjs unicode library to zig.
Conclusion
This week has only been about research, Next week I will be picking what I let this week.


I am I-No Liao, currently a student pursuing Master of Computer Science degree at Rice University. My professional interests lie in areas of web development, database systems design, parallel programming, and machine learning. I am actively looking for 2020 summer internship opportunities as a Software Development Engineer.
I was a research assistant in Advanced Database System Lab at National Chiao Tung University. My research focus was on large-scale image information retrieval, visual recognition, and deep learning. I was particularly keen on using artificial intelligence to enhance professional sports analysis so as to assist athletes in augmenting both on-court performance and off-court training.
In my leisure, I participate in art activities. Art not only rejuvenates me from work but inspires my creativity, providing great help for my career as a software developer. In various fields of art, I am especially passionate about contemporary arts. I believe that contemporary artists' pursuit is the driving force behind scientific and technological progress. By learning from these pioneers, I expect myself to make human civilization a step forward through developing advanced technologies. As an enthusiastic software engineer, it is my ultimate lifetime mission.


County Armagh man charged over discovery of 39 bodies in Essex truck
by Michael StainesA man from County Armagh has been charged with human trafficking offences in connection with the discovery of 39 bodies in a refrigerated truck in the UK last month.
23-year-old Christopher Kennedy from Corkley Road in Darkley was arrested in Buckinghamshire on Friday.
This morning, Essex Police said he would be charged with conspiracy to arrange or facilitate the travel of people with a view to exploitation and conspiracy to facilitate the commission of a breach of UK immigration law.
He is due to appear before Chelmsford Magistrates’ Court tomorrow.
Bodies
The bodies of the 39 Vietnamese nationals were found in a refrigerated container in Grays, Essex on October 23rd.
The Lorry had arrived in the UK from Belgium.
Mr Kennedy was arrested on the M40 in Beaconsfield, Buckinghamshire in the early hours of Friday morning.
Investigation
The 25-year-old driver of the lorry, Maurice Robinson from Craigavon in County Armagh, has already been charged in connection with the discovery.
He faces 39 counts of manslaughter, conspiracy to traffic people, conspiracy to assist unlawful immigration and money laundering.
Meanwhile, police in the UK have issued a European Arrest Warrant for 22-year-old Eamon Harrison from Mayobridge in County Down who is currently in custody in Ireland.
He is suspected of delivering the container to a port in Belgium, from where it was then transported to England.
He faces 39 charges of manslaughter, a charge of human trafficking and one charge of conspiring to assist unlawful immigration.
On Thursday, a High Court judge overseeing the extradition proceedings requested more information from UK authorities.
The hearing has been adjourned until December 12th.
Essex Police are continuing to appeal for two brothers Ronan and Christopher Hughes to come forward.
They are wanted on suspicion of manslaughter & people trafficking.


Arrays vs. Hashes
What are they?
our_array = [ 3, "cat", true, [], {} ]
An array is a list(or collection) of objects/data that is ordered by indexed-position. Because computers always start count from zero indexing begins at 0 for the first position, 1 for the second position, 2 for the third position and well you get the idea... Indexing makes it simple to access the objects of an array through it's position, for example our_array[1] would return "cat". Arrays can hold just about anything you throw at it integers, booleans, strings, hashes even other arrays.
our_hash = { "Phone Number:" => '555-555-5555', "Address:" => '1 Elm St, San Jose, CA 95123' }
Hashes store data in the form of an unordered list made of key-value pairs, unlike arrays' indexed-positioning, hashes are accessed through their unique keys. You're free to assign the uniques key and values to anything you like, for example:
{'color' => 'orange'} or '{food' => 'chicken wings'}
}
What are they good for?
Hashes and Arrays are data containers you can use as a reference, for example: when you need to decipher a certain North Korean message.
How do you know which one to use?
If you need to store data in a particular order you should use arrays. Like the alphabet:
["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]
If you're storing data with unique keys, and varying values like a contact list for example you should use a hash.contacts = { 'moms' =><PHONE_NUMBER>, 'dad' =><PHONE_NUMBER>, 'pizza' => speed dial #1 }


Web Developer & Graphic Designear.
I'm a Website Developer, I use HTML, CSS and JavaScript to Create Website. I am an Expert in The Frontend But also work on Backend.
Download CVIn web Design We Provide You Blogger Theams, WordPress Theams and Source Code Files of HTML, CSS and Javacript.
In Advertising Services: We Advertising You'r Webside, Bloge, Youtube Channel(watch Time and Subsciber) and You'r Apps.
In Graphic Designing Servces: We Make Logo, Business Card, Label Design, Web Design, Flyer Design, 3D and Vector Design
I am Expert in Web Development, sum Programming Languages are bigner Lavel Like Java C++ and C.
In Graphic Designig I'm Expert in PhotoShop and Bigner in UX/UI Desiging.
Team Leader, Web Developer and Graphic Designear.
Team 2nd Leader, Programmer and Data Base Scientist.
Backend Developer And Data Manager.
YouTuber and Vlogger.
Freelancer & Blogger.
Text Me E-mail


Could some one explain how to incorporate the drop down menu in BBLog (the one you get when clicking signature, server radar, etc). I've been playing around with it for a few days and can't seem to figure it out.
Post edited 1 x times, last by
BrainFooLong
Administrator
BrainFooLong
Administrator
It is not really a dropdown menu.
It scrolls to a specific point when you click on it.
Here is a quick jQuery example for it - You must have a valid page for it (with  and  tag):
HTML Code: <input type="button" onclick="scrollToElement('#anchor')" value="Click Me"/>

Scroll to me

JS Code: function scrollToElement(selector){
$("html,body").animate({scrollTop : $(selector).offset().top});
}


I am currently a post-graduate student at MSc"Advanced Informational Systems" - University of Piraeus. During my studies, I have been trained on object-oriented programming, mobile development, cloud computing and web development.
We have the latest informations at the tips of our finger. Let's use this power...
Everything is so overwhelming... Which is the most suitable for my needs?
Recognise the red line between usability and design.
My education is based on software and web development. Beneath, I have listed all my skills.
I always try to keep my code readable, so as to be easily maintained in the future. Also, I have a lot of experience working as a member of a team, and I believe that continuous communication between the co-workers is the key to success.


If you want to use database, you must enable it in sessions and update your connection information.
This framework is opensource and free.


Class Roll: Reddam House Primary School (Thursday Python)
Student Name
7/2/18
14/2/18
21/2/18
28/2/18
7/3/18
14/3/18
21/3/18
28/3/18
4/4/18
11/4/18
Change Class
Zara Erder
Luca Juma-Ross


My name is Ahmad Rangeen. I grew up in Mountain View, Ca for most of my life. Ever since I was a kid, I’ve always loved solving problems. Whether it is a math problem or a life problem, I always enjoyed thinking of ways to solve problems and make peoples life easier. This is why I decided to attend San Francisco University to study Computer Science because after I took a Java class at a community college, I feel in love with coding right away. It’s like you are given a problem to solve(code) and you can solve it however you want. The biggest thing I love coding is the challenge. Everything is so complicated
and takes a bit of time to figure out but once you figure it out and make your code work, it is the greatest feeling in the world. I graduated with a Bachelor degree of Science, Computer Science with the class of 2019. My hobbies are coding, playing Basketball and Football. I also enjoy going out with friends to watch games and just relax . For the past 2 years, I have been coding as much as I can to improve my skill. I played organized basketball for 8 years and organized football for 4 years as a running back.
Map Picture Generator App is an IOS app. This app has the Apple Maps as the home page. There is a pin on the map the shows user location. You can move around the map and drop a pin anywhere you want. After pin is dropped, Flickr API is used to get all photos that people posted within a mile radius of the dropped pin. You can scroll through the photos, you can click on a photo to zoom in or you can drop more pins and view more photos from different parts of the map. To center back on user location, just click on the button that is on bottom right of the screen.
https://github.com/FinalAppCSC690/FinalApp
Close ProjectTo-Do App is an IOS app. You can use this app to keep track of all the things you need to do through out the day. The home page shows you two secitons. First section, Todo section, is all the things you need to get done and you can add to that list as much as you want. AFter you complete one of the to-do's on the list, you can mark it as done and it will be shown in the second section called, Done, of the home page, which is all the things you completed. The point of this section is to show you what you have done through out the day so far and if you haven't done enough, this will help you realize that and should motivate you to start doing more. To add more items, you can click the plus sign on the top-right corner of the app.
https://github.com/arangeen/TodoApp
Close ProjectThis sections has ALL my Intro to Java and Data Structures in Java projects. My favorite project that I worked on in this seciton is the "Slot Machine" one. The Slot Machine is basically a gambling games with three spinning reels. The reels display symbols that spin and land randomly to form potential winning combinations after a player places a bet.
https://github.com/arangeen/Java1and2-Projects
Close ProjectThis section has my C++ projects that are Advanced data structures and algorithms for manipulation. Emphasis on design and implementation. Practical applications; algorithms for sorting, searching, and graphs. My favorite project that I have in this seciton is called, TicTacToe, which is a TicTacToe game but instead of a three by three grid, it is a four by four grid.
https://github.com/arangeen/Programming-Methodology
Close Project“GATORHOUSING” website is basically developed by the engineers for the betterment of SF STATE students where they can rent a property (apartment, condo). This will help SF State students to get cheaper housing and will also give relief from being waitlisted for on-campus housing. SF State students can basically login or register and see the posts posted from landlord. The unique about the website is it’s only for SF State students.
https://github.com/arangeen/Software-Engineering
Close ProjectLorem ipsum dolor sit amet, consectetur adipisicing elit. Mollitia neque assumenda ipsam nihil, molestias magnam, recusandae quos quis inventore quisquam velit asperiores, vitae? Reprehenderit soluta, eos quod consequuntur itaque. Nam.
Close Project


| Path: | vendor/plugins/flotomatic/README |
| Last Update: | Thu Dec 03 17:40:24 -0600 2009 |
Flotomatic is a Rails wrapper around the flot javascript graphing library.
Flotomatic was originally developed for graphing migraine histories on MigraineLiving.com.
Known issues:
To install the flotomatic plugin:
script/plugin install git://github.com/xdotcommer/flotomatic.git
The following rake tasks are also available:
@flot = TimeFlot.new('graph') do |f| f.bars f.grid :hoverable => true f.selection :mode => "xy" f.filter {|collection| collection.select {|j| j.entry_date < Date.parse("7/8/2007")}} f.series_for("Stress", @journals, :x => :entry_date, :y => :stress_rating) f.series_for("Hours of Sleep", @migraines, :x => :entry_date, :y => :hours_of_sleep) f.series_for("Restful Night?", @migraines, :x => :entry_date, :y => lambda {|record| record.restful_night ? 5 : 0 }, :options => {:points => {:show => true}, :bars => {:show => false}}) f.series_for("Migraines", @migraines, :x => :entry_date, :y => lambda {|record| record.migraine? ? 4 : nil }, :options => {:points => {:show => true}, :bars => {:show => false}}) end
<%= flot_includes %>
Graph the following items

 <%= flot_selections %>

My Graph
 <%= flot_canvas("graph") %>
Zoom In / Out
 <%= flot_overview("asdflkjasdf") %>  <% flot_graph("graph", @flot) do %> <%= flot_plot(:dynamic => true, :overview => true) %> <%= flot_tooltip %> <% end %>
Within the <% flot_graph %> block you will have access to the flotomatic variable.
The flotomatic variable is created with the id of the canvas div, the data, and options supplied through the Flot object passed in to the flot_graph call. For instance:
<% flot_graph("canvas", @flot) %> // Results in the following: var flotomatic = new Flotomatic("canvas", @flot.data, @flot.options)
Plotting Methods
// actually draws the plot with $.plot draw: function(placeholder, data, initialOptions, ranges, dynamic, zoom) // calls draw & sets flotomatic.plot to the returned plot handle graph: function(overview, dynamic) // dynamically graphs with choice input checkboxes for each dataset in flotomatic.data graphDynamic: function() // plots the overview (zoom in / out) graph graphOverview: function()
Tooltip Methods
createTooltip: function(tooltipFormatter) // default tooltipFormatter tooltipFormatter: function(item) { var date = new Date(item.datapoint[0]), label = item.series.label; return label + ": " + item.datapoint[1] + " on " + (date.getMonth() + 1) + "/" + date.getDate() + ""; }
Copyright (c) 2009 Michael Cowden, released under the MIT license


Toggle navigation
Mentoring
Questions
Stories
People
Sign Up
Sign In
Username
Password
Remember me
Trans*Network Mentor FAQ
What is a mentor?
Mentor is someon that is there to support you and answer ....
Why should I mentor?
You should be a mentor because this is a chance to ...
What can I do as a mentor?
As a mentor you get to ...
Think you are ready?
Become a mentor


Bi-directional bi-objective point-to-point shortest path. More...
#include <BiDirectionalPoint2PointBSP.h>
Public Member Functions | |
| BiDirectionalPoint2PointBSP (StarNetwork &net, const TollContainerType &tolls, BoundsCalculatorForBSPBase &bounds, const PathsAdder &pathAdder, BoundsCalculatorForBackwardNet &backwardBounds, DominationByPathCostBase &dominanceRule) | |
| virtual void | createPath (BiObjLabel *labelWithMinCost, std::list< StarLink * > &path) |
| Public Member Functions inherited from LabelSettingPoint2PointBSP | |
| LabelSettingPoint2PointBSP (StarNetwork &net, const TollContainerType &tolls, BoundsCalculatorForBSPBase &bounds, const PathsAdder &pathAdder, DominationByPathCostBase &dominanceRule) | |
| virtual void | calculate (int originIndex, int destIndex, int odIndex) |
| Public Member Functions inherited from Point2PointBiObjShPath | |
| const BiObjLabelContainer & | getLabels () |
Protected Member Functions | |
| virtual QueueType * | initLabels (BiObjLabel *originLabel, BiObjLabelContainer &labels) |
| virtual bool | stillLookingForLabels (const QueueType &tmpLabels) const |
| virtual QueueType * | changeDirectionIfNeeded () |
| virtual BiObjLabelContainer * | changeLabelsIfNeeded (BiObjLabelContainer *labels) |
| virtual StarNode * | beginNode (int owner) const |
| virtual StarLink * | beginLink () const |
| virtual StarLink * | getNextLink () const |
| virtual bool | isWorthAdding (FPType newTime, TollType newToll, int nodeIndex) const |
| virtual void | combine (BiObjLabel *newLabel) |
| virtual void | addLabelToLabelSet (BiObjLabelContainer &labels, int nodeIndex, BiObjLabel *label) |
| Protected Member Functions inherited from LabelSettingPoint2PointBSP | |
| int | getDestIndex () const |
| bool | isWorth (FPType timeLowerBound, TollType tollLowerBound) const |
| virtual void | uploadPaths () |
| Protected Member Functions inherited from Point2PointBiObjShPath | |
| Point2PointBiObjShPath (int nbNodes) | |
| Protected Member Functions inherited from LabelSettingBSPBase | |
| LabelSettingBSPBase (StarNetwork &net, const TollContainerType &tolls) | |
| void | calculateBSP (int originIndex, BiObjLabelContainer &labels) |
| virtual BiObjLabel * | getNextLabelAndRemoveItFromList (QueueType &tmpLabels) |
| bool | isNonDominated (FPType newTime, TollType newToll, const BiObjLabelContainer &labels, int linkHead) const |
| void | mergeLabels (BiObjLabel *label, BiObjLabelContainer &labels, int linkHead, QueueType &tmpLabels) |
Private Attributes | |
| QueueType | backwardList_ |
| QueueType * | forwardList_ |
| BiObjLabelContainer | backwardLabels_ |
| BiObjLabelContainer * | forwardLabels_ |
| StarNetwork * | reversedNet_ |
| bool | curDirectionIsBackward_ |
| int | backwardOriginIndex_ |
| BoundsCalculatorForBackwardNet & | backwardBounds_ |
Additional Inherited Members | |
| Protected Attributes inherited from LabelSettingPoint2PointBSP | |
| int | currOdIndex_ |
| DominationByPathCostBase & | dominanceRule_ |
| Protected Attributes inherited from Point2PointBiObjShPath | |
| BiObjLabelContainer | labels_ |
| Protected Attributes inherited from LabelSettingBSPBase | |
| StarNetwork & | net_ |
| const TollContainerType & | tolls_ |
Detailed Description
Bi-directional bi-objective point-to-point shortest path.
Constructor & Destructor Documentation
| BiDirectionalPoint2PointBSP::BiDirectionalPoint2PointBSP | ( | StarNetwork & | net, |
| const TollContainerType & | tolls, | ||
| BoundsCalculatorForBSPBase & | bounds, | ||
| const PathsAdder & | pathAdder, | ||
| BoundsCalculatorForBackwardNet & | backwardBounds, | ||
| DominationByPathCostBase & | dominanceRule | ||
| ) |
- Parameters
-
net network. tolls container with link tolls. bounds object that implement travel time lower bounds. pathAdder object for adding known paths to the destination node. backwardBounds travel time bounds for network with reversed links. dominanceRule object that implements path cost domination rule.
Member Function Documentation
|
protectedvirtual |
Adds label to label set.
Reimplemented from LabelSettingPoint2PointBSP.
|
protectedvirtual |
Depending on direction returns link of forward network or reversed network.
Reimplemented from LabelSettingBSPBase.
|
protectedvirtual |
Depending on direction returns node of forward network or reversed network.
Reimplemented from LabelSettingBSPBase.
|
protectedvirtual |
Changes direction of search.
- Returns
- reference to backward list if NEW direction is backward, otherwise calls parent method and return its return value.
Reimplemented from LabelSettingBSPBase.
|
protectedvirtual |
Changes set of labels depending on search direction.
- Parameters
-
labels set of forward labels.
- Returns
- pointer to backward labels if direction is backward, if direction is not forward, returns input set of labels.
Reimplemented from LabelSettingBSPBase.
|
protectedvirtual |
Combines backward and forward labels that belong to the same path.
- Parameters
-
newLabel newly generated label.
Reimplemented from LabelSettingBSPBase.
|
virtual |
Builds path from a given label.
- Parameters
-
labelWithMinCost label to restore path from. path empty path object where links will be added after method call.
Reimplemented from LabelSettingPoint2PointBSP.
|
protectedvirtual |
Depending on direction returns link of forward network or reversed network.
Reimplemented from LabelSettingBSPBase.
|
protectedvirtual |
- Note
- Must call parent initLabels() first and return whatever parent returns. In addition adds destination label to backward list and to backward labels.
- Parameters
-
originLabel label contained in the origin node. labels container of all stored labels.
- Returns
- pointer to the data structure with forward labels used to check stopping condition.
Reimplemented from LabelSettingBSPBase.
|
protectedvirtual |
- Returns
- true if new label with cost vector [newTime, newToll] is worth exploring, false otherwise.
Reimplemented from LabelSettingPoint2PointBSP.
|
protectedvirtual |
Implements stopping condition for bi-directional search.
- Parameters
-
tmpLabels list with all not yet visited labels.
- Returns
- true if the algorithm has not finished yet, false otherwise.
Reimplemented from LabelSettingPoint2PointBSP.
Member Data Documentation
|
private |
non-dominated backward labels stored for each node.
|
private |
list of not yet visited backward labels.
|
private |
index of the origin node, node indexes in reversed and forward networks are the same, but link indexes are not the same.
|
private |
true if backward, false otherwise.
|
private |
non-dominated forward labels stored for each node.
|
private |
list of not yet visited forward labels.
The documentation for this class was generated from the following files:
- BiDirectionalPoint2PointBSP.h
- BiDirectionalPoint2PointBSP.cpp


- Member asylo::CleansingString
- Use
CleansingVector
instead.
- Member asylo::CreateDefaultEnclaveConfig (const HostConfig &host_config)
- Returns an EnclaveConfig proto with critical fields initialized to default values.
- Class asylo::EnclaveManager
- Users of this class first supply a configuration using the static Configure() method, and then get a pointer to the singleton instance as specified by this configuration by calling the static Instance() method.
- Member asylo::EnclaveManager::Configure (const EnclaveManagerOptions &options)
- EnclaveManager no longer needs to be configured.
- Member asylo::EnclaveManager::LoadEnclave (absl::string_view name, const EnclaveLoader &loader, EnclaveConfig config, void *base_address=nullptr, const size_t enclave_size=0)
- Use LoadEnclave(const EnclaveLoadConfig &load_config)
- Member asylo::EnclaveManager::LoadEnclave (absl::string_view name, const EnclaveLoader &loader, void *base_address=nullptr, const size_t enclave_size=0)
- Use LoadEnclave(const EnclaveLoadConfig &load_config)
- Class asylo::EnclaveManagerOptions
- EnclaveManager no longer needs to be configured.
- Member asylo::experimental::AeadCryptor
AeadCryptor
has been moved to the asylo
top-level namespace.
- Member asylo::experimental::ExecTester::BuildSiblingPath (const std::string &path, const std::string &file_name)
- Use Bazel's runfiles library for file paths.
- Member asylo::IdentityExpectationMatcher::Match (const EnclaveIdentity &identity, const EnclaveIdentityExpectation &expectation) const
- Use MatchAndExplain instead
- Member asylo::SetEnclaveConfigDefaults (const HostConfig &host_config, EnclaveConfig *config)
- Sets critical uninitialized fields in
config
to default values.


public class RatingMatrix
extends java.lang.Object
matrix
.
If this is a user rating matrix, each row is a vector of rating values that a user gives on many items.
In other words, rows in user rating matrix correspond with users and columns in user rating matrix correspond with items.
If this is an item rating matrix, each row is a vector of rating values that an item is received from many users.
In other words, rows in item rating matrix correspond with items and columns in item rating matrix correspond with users.
In a rating matrix, all values at the same row constitute a row vector and all values at the same column constitute a column vector.
Row vectors and column vectors are extracted from the internal real matrix matrix
.| Modifier and Type | Field and Description |
|---|---|
java.util.List<java.lang.Integer> |
columnIdList
Essentially, this variable is a mapping from a column to an ID.
|
float[][] |
matrix
The public variable for fast access, representing a matrix of rating values.
|
RatingMatrixMetadata |
metadata
This variable is meta-data of rating matrix which stores additional information of rating matrix.
|
java.util.List<java.lang.Integer> |
rowIdList
Essentially, this variable is a mapping from a column to an ID.
|
| Constructor and Description |
|---|
RatingMatrix() |
| Modifier and Type | Method and Description |
|---|---|
Vector |
apply(Vector vector)
Multiplying (applying) this rating matrix with the specified vector.
|
static RatingMatrix |
assign(float[][] matrix,
java.util.List<java.lang.Integer> rowIdList,
java.util.List<java.lang.Integer> columnIdList,
RatingMatrixMetadata metadata)
This static method firstly creates a new rating matrix and then assigns all variables of such new rating matrix by specified parameters.
|
void |
assign(RatingMatrix that)
Assigning all variables of this rating matrix by variables of specified rating matrix.
|
void |
clear()
Clearing this rating matrix, which means that making this rating matrix empty.
|
RatingMatrix |
createSub(java.util.List<java.lang.Integer> columnIdList,
boolean updateMetadata)
Creating a sub-matrix of this rating matrix.
|
float[] |
getColumnVector(int columnId)
Extracting a column vector at the specified column ID.
|
float[] |
getRowVector(int rowId)
Extracting a row vector at the specified row ID.
|
float |
getValue(int rowId,
int columnId)
Getting the value at specified row ID and specified column ID.
|
boolean |
isEmpty()
Checking whether this rating matrix is empty.
|
void |
load(java.io.Reader reader)
Reading (loading) this rating matrix from the specified
Reader . |
void |
save(java.io.Writer writer)
Saving this rating matrix to specified
Writer . |
void |
transpose()
Transposing this rating matrix.
|
void |
updateMetadata()
This method updates the meta-data of this rating matrix.
|
public float[][] matrix
public java.util.List<java.lang.Integer> rowIdList
rowIdList.get(0)
returns the same user ID of all rating values at the first row.
If this is an item rating matrix, this variable is a vector of item identifications (item IDs).
;for example rowIdList.get(0)
returns the same item ID of all rating values at the first row.
As a convention, this variable is called row ID list
and every its element is called row ID
.public java.util.List<java.lang.Integer> columnIdList
rowIdList.get(0)
returns the same item ID of all rating values at the first column.
If this is an item rating matrix, this variable is a vector of user identifications (user IDs).
;for example rowIdList.get(0)
returns the same user ID of all rating values at the first column.
As a convention, this variable is called column ID list
and every its element is called column ID
.public RatingMatrixMetadata metadata
RatingMatrixMetadata
class.
In general, every rating matrix is always associated with a meta-data.public RatingMatrix createSub(java.util.List<java.lang.Integer> columnIdList, boolean updateMetadata)
columnIdList
is sub-set of the column ID list of this rating matrix.
In other words, this static method extracts a child matrix of this rating matrix by shrinking this rating matrix according to columns.columnIdList
- column ID list of the sub-matrix which is sub-set of the column ID list of this rating matrix.updateMetadata
- whether or not updating the meta-data of the sub-matrix.public static RatingMatrix assign(float[][] matrix, java.util.List<java.lang.Integer> rowIdList, java.util.List<java.lang.Integer> columnIdList, RatingMatrixMetadata metadata)
matrix
- specified data matrix assigned to the data matrix of the returned rating matrix.rowIdList
- specified row ID list assigned to the row ID list of the returned rating matrix.columnIdList
- specified column ID list assigned to the column ID list of the returned rating matrix.metadata
- specified meta-data assigned to the meta-data of the returned rating matrix.public void assign(RatingMatrix that)
that
- specified rating matrix.public boolean isEmpty()
public void clear()
public float[] getRowVector(int rowId)
rowId
- specified row ID.public float[] getColumnVector(int columnId)
columnId
- specified column ID.public float getValue(int rowId, int columnId)
rowId
- specified row ID.columnId
- specified column ID.public void transpose()
public Vector apply(Vector vector)
vector
- specified vector.public void save(java.io.Writer writer)
Writer
.writer
- specified Writer
.public void load(java.io.Reader reader)
Reader
.reader
- specified Reader
.public void updateMetadata()


WITNESS LIST Appropriations-S/C on Regulatory Committee (Subcommittee on Regulatory) February 6, 2001-8:00A Budget On: Brown, Will (DIR) Dodson, Gay (Texas State Board of Pharmacy) Ewald, Lois (Texas Optometry Board) Hendricks, Cathy (Texas Board of Architectural Examiners) Hill, Jeffry (State Board of Dental Examiners) Hsu, Victoria (Texas Board of Professional Engineers) Lee, Sherry (Texas State Board of Examiners of Psychologists) Maline, John (Executive Council of PT/OT Examiners) Maxwell, Robert (Texas State Board of Plumbing Examiners) O'Neal, Henry (Texas Cosmetology Commission) Purcell, Carolyn (Department of Information Resources) Smith, Sandra (Texas Funeral Service Commission) Smith, Sandy (Texas Board of Professional Land Surveying) Stella, Cathy (Texas State Board of Pharmacy) Strange, Mary (Board of Vocational Nurse Examiners) Thomas, Katherine (Board of Nurse Examiners)


Course
Become A React Ninja
View all chapter
Module 3
6/10 Challenges
Guess the Number Game
Continue


Your order is placedDummy text of the printing and typesetting industry.
New Message receivedYou have 87 unread messages
Your item is shippedIt is a long established fact that a reader will
Jabatan, Cabang
Edit data profile sesuai kebutuhan anda.
Pastikan password yang anda ganti memiliki satu huruf kapital dan kombinasi nomor.


Copyright (C) 2009 The Android Open Source Project Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
Vrs 1.0
Content Authoring Application for the
JET Interactive Music Engine
Authored by SONiVOX
Copyright 2009 Sonic Network, Inc.
This document contains the user guidelines
for the SONiVOX JET Creator, an authoring application for creating and
auditioning JET files. JET is an interactive music player for small embedded
devices, including the Google Android platform. It allows applications to
include interactive music soundtracks, in
JET works in conjunction with SONiVOX’s
Embedded Audio Synthesizer (EAS) which is the
In addition to the graphical user
interface, there are two main functionalities taking place in JET Creator. The
first involves gathering all the source data (
The JET Creator application is written in the Python programming language, therefore you need to have the current version of Python and WXWidgets installed. There is both a Mac and Windows version.
It is important to use a common set of
terms to minimize confusion. Since JET uses
Channel: MIDI data associated with a specific
Controller: A
DAW: Digital Audio Workstation. A common term for
EAS: Embedded
JET: Jet Interactive Engine. The name of the SONiVOX JET interactive music engine.
M/B/T: Measures, Beats and Ticks
Segment: A musical section such as a chorus or verse that is a component of
the overall composition. In JET, a segment can be an entire MIDI file or a
derived from a portion of a
SMF-0: Standard MIDI File Type 0, a MIDI file that contains a single
track, but may be made up of multiple channels of
SMF-1: Standard MIDI File Type 1, a MIDI file that contains a one more
tracks, and each track may in turn be made up of one or more channels of
Track: A single track in a DAW containing a timed sequence of
Interactive music can be defined as music that changes in real-time according to non-predictable events such as user interaction or game play events. In this way, interactive music is much more engaging as it has the ability to match the energy and mood of a game much closer than a pre-composed composition that never changes. In some applications and games, interactive music is central to the game play. Guitar Hero is one such popular game. When the end user successfully ‘captures’ the musical notes coming down the fret board, the music adapts itself and simultaneously keeps score of successes and failures. JET allows for these types of music driven games as well.
There are several methods for making and controlling interactive music and JET is one such method. This section describes the features of JET and how they might be used in a game or software application. It also describes how JET can be used to save memory in small footprint devices such as Android enabled mobile handsets.
JET supports a flexible music format that can be used to create extended musical sequences with a minimal amount of data. A musical composition is broken up into segments that can be sequenced to create a longer piece. The sequencing can be fixed at the time the music file is authored, or it can be created dynamically under program control.
Figure 1: Linear Music Piece
This diagram shows how musical segments are
stored. Each segment is authored as a separate
The bottom part of the diagram shows how the musical segments can be recombined to create a linear music piece. In this example, the bridge might end with a half-step key modulation and the remaining segments could be transposed up a half-step to match.
Figure 2: Non-linear music piece
In this diagram, we see a non-linear music piece. The scenario is a first-person-shooter (FPS) and JET is providing the background music. The intro plays as the level is loading and then transitions under program control to the Searching segment. This segment is repeated indefinitely, perhaps with small variations (using the mute/un-mute feature) until activity in the game dictates a change.
As the player nears a monster lair, the program starts a synchronized transition to the Danger segment, increasing the tension level in the audio. As the player draws closer to the lair, additional tracks are un-muted to increase the tension.
As the player enters into combat with the monster, the program starts a synchronized transition to the Combat segment. The segment repeats indefinitely as the combat continues. A Bonus Hit temporarily un-mutes a decorative track that notifies the player of a successful attack, and similarly, another track is temporarily un-muted to signify when the player receives Special Damage.
At the end of combat, the music transitions to a victory or defeat segment based on the outcome of battle.
JET can also synchronize the muting and un-muting of tracks to events in the music. For example, in the FPS game, it would probably be desirable to place the musical events relating to bonuses and damage as close to the actual game event as possible. However, simply un-muting a track at the moment the game event occurs might result in a music clip starting in the middle. Alternatively, a clip could be started from the beginning, but then it wouldn’t be synchronized with the other music tracks.
However, with the JET sync engine, a clip
can be started at the next opportune moment and maintain synchronization. This
can be accomplished by placing a number of short music clips on a decorative
track. A
Figure 3: Synchronized Mute/Unmute
JET provides an audio synchronization API
that allows game play to be synchronized to events in the audio. The mechanism
relies on data embedded in the
Figure 4: Music Game with Synchronization
The arrows represent events in the music sequence where game events need to be synchronized. In this case, the blue arrow represents a time where the player is supposed to press the left button, and the red arrow is for the right button. The yellow arrow tells the game engine that the sequence is complete. The player is allowed a certain time window before and after the event to press the appropriate key.
If an event is received and the player has not pressed a button, a timer is set to half the length of the window. If the player presses the button before the timer expires, the game registers a success, and if not, the game registers a failure.
If the player presses the button before the event is received, a timer is set to half the length of the window. If an event is received before the timer expires, the game registers a success, and if not, the game registers a failure. Game play might also include bonuses for getting close to the timing of the actual event.
To author JET files and hear them playback
interactively, the content author will work in two applications which are
designed to work together smoothly. The first is application is any
off-the-shelf
Please see the JET Content Authoring Guidelines documentation for additional details on content authoring.
JET Creator is a python language application, therefore, you must have Python and wxPython installed on your machine.
JetCreator was created and tested with:
Python Version 2.5.4
wxPython Version <IP_ADDRESS>
These can be downloaded here:
PC:
http://www.python.org/download/releases/2.5.4/
http://www.wxpython.org/download.php
MAC:
http://wiki.python.org/moin/MacPython/Leopard
http://www.wxpython.org/download.php
After installing Python and wxPython, simply unzip or copy all the files in the JET Creator application directory to a folder on your hard drive.
To launch JET Creator go to a command prompt and set the directory to where you’ve installed Python. Next run python with the command:
python
jetcreator.py
There are a few different file types associated with JET Creator.
.jtc JET Creator project file. This file contains all the information associated with a JET Creator project. When you Save or Save-as out of JET Creator, this file type is saved.
.jet JET File. This output file is automatically generated from JET Creator whenever you save your JET Creator project. This is the file that bundles all JET assets together into a single file that the Android application will use. Give this file to the Android application developer.
.mid
.seg Segment
File. This is a JET Segment file. It has the same name as the
.zip Zip Archive file. When you Export a JET Archive, a zip file is created that contains all the assets (files) necessary for JET Creator. Use this to transfer JET Creator projects to other people.
When you first launch JET Creator you are presented with an open dialog like the following.
Open will open an existing .jtc (JET Creator file) file. Use the browser button to browse to the directory where you have saved your .jtc file.
New will create a new .jtc file.
Import will import a JET Archive (.zip) file.
Cancel will cancel the dialog and exit the application.
The main window of the JET Creator application looks like the picture below. There are three main sections from top to bottom: segment view, event view, and timeline.
The segment view section displays a list of
the current segments, which
Just below the Segment view is the event view. The event view section displays all events associated with a given segment. Events only display when the segment they are assigned to is highlighted. Each event displays its type, start and end points, track and midi channel assignment, and its event ID.
Just below the Event view is the timeline display. The timeline shows how many measures a given segment is as well as any events associated with that segment. The timeline changes to display the currently selected or playing segment. You can trigger an event in this window while the segment is play by simply clicking on the event in the timeline display.
JET
Creator Main Window
The buttons along the left side of main window do the following:
Add: - Displays the segment or event window for adding a new segment or event
Revise: - Displays the segment or event window for updating an existing segment or event
Delete: - Deletes the selected segment or event (will ask for confirmation)
Move: - Displays the move window which allows you to move selected segments or events in time
Queue All: - Queue’s (selects) all segments for playback
Dequeue All: - Dequeue’s (deselects) all segments
Play: - Starts playback of all queue’d segments. This button changes to Stop if any segments are playing
Audition: - Displays the Audition window (see below)
The segment window is where a given segment’s attributes are assigned and auditioned, as shown in the picture below. The left side of the window displays the segments attributes that are stored in the JET file. The right side of the window allows the author to set mute flags, repeat and transpose settings and audition the segment as it will play in the JET game.
Note: the audition attributes (mute flags, repeat and transpose) are not stored in the JET content file (.jet) but rather are defined by the game or application itself. In programming language, these settings correspond directly with the API calls to the JET engine. By including them here, the JET content author can simulate how the segment will respond to the applications API commands during game play.
The segment parameters do the following:
Segment Name - Sets the name of the segment
MIDI File -
The name and location of the
DLS File -
The name and location of the DLS2 file, if any, that the
Starting M/B/T - Starting measure, beat and tick of the segment
Ending M/B/T - Ending measure, beat and tick of the segment
Quantize - Quantize value for quantizing the current segment during playback
The audition fields are as follows:
Track Mutes -
Shows the MIDI tracks (not channels)
in the
Channel -
Displays the
Name - Displays the track name meta event (if present) for each track
Repeat - Indicates the number of times a segment should repeat during playback
Transpose - Indicates the transposition in semi-tones or half-steps a segment should transpose during playback
To the right of the Audition window are a few additional buttons. These do as follows:
OK - Selecting OK confirms all segment settings and closes the segment window
Cancel - Selecting Cancel cancels any changes and closes the segment window
Replicate - Displays the Replicate Segment window for entering multiple segments at once. See below.
Play/Stop Segment - Starts or Stops playback of the segment using the segment attributes assigned.
Play/Stop MIDI File -
Starts or Stops playback of the
Pause/Resume - Pauses or Resumes playback.
The event window is where a given segment’s event attributes are assigned and auditioned, as shown in the picture below. To add an event to a segment, the author must first select the segment which will contain the event, then select the Add button. This will bring up the Event window.
There are two main sections to the event window. The segment section on the left side of the event window is for display only. It shows what the segment attributes are for the given segment. The Event section, on the right side, is where events can be assigned. The following parameters are available:
Event Name - Assigns a name to an event
Event Type - Selects which type of event to assign.
Starting M/B/T - Sets the starting measure, beat, and tick for the event
Ending M/B/T - Sets the ending measure, beat, and tick for the event, if applicable
Track - Sets which track in the given segment the event will apply to
Channel -
Sets which
Event ID - Sets the event ID for the event. Multiple events can be assigned to the same segment and therefore the Event ID is used to identify them
To the right of the Audition window are a few additional buttons. These do as follows:
OK - Selecting OK confirms all event settings and closes the event window
Cancel - Selecting Cancel cancels any changes and closes the event window
Replicate - Displays the Replicate Event window for entering multiple events at once. See below.
Play/Stop - Starts or Stops playback of the segment using the segment attributes assigned. While the segment is playing, events can be triggered and auditioned.
Trigger - Triggers the event assigned. This replicates the API command that the JET game will use to trigger the event, therefore giving the content author a method for auditioning the behaviour of the event.
Mute/UnMute - Mute/UnMute will mute or unmute the track that the event is assigned to
Pause/Resume - Pauses or Resumes playback.
To audition the behaviour of an event, you can select the Play button. This will initiate playback. The trigger button will send the trigger event when pressed. This is equivalent to selecting the green trigger event in the timeline.
Note: Trigger events are meant to unmute a single track of a segment when triggered, then mute that track at the end of the trigger segment. Therefore you should make sure the mute flag is set to mute the track that a trigger event will be unmuting when receiving a trigger event.
Please read Section 7 “Under The Hood” below for details on how trigger events work and behave.
Often in creating JET files, you’ll need to create tens or even hundreds of events. You may also need to move events. The Replicate and Move windows allow for this. There are two Replicate windows for creating multiple segments or events. They look like the following:
Replicate Segment Window
Replicate Event Window
Both Replicate windows function the same. After creating an initial segment or event, you can select the Replicate button. The parameters are as follows:
Name Prefix - Sets the prefix for the name of each segment or event created
Starting M/B/T - Sets the starting time for the first segment or event
Increment M/B/T - Sets the time between segments or events created.
Number -
Sets the number of segments or events you wish to create. If the number
overflows the length of the
Preview - Preview allows you to examine the objects created before saying OK to insert them.
The Move function acts similarly to the Replicate function in that it allows you to edit multiple segments or events at one time, in this case move them in time. Like Replicate, there are two Move windows, one for Segments and one for Events. The windows look like the following:
Move Event Window
To use Move, first select the segments or events you wish to move in time, then click the Move button. The parameters are as follows:
Starting M/B/T - Sets the starting time for the first segment or event
Increment M/B/T - Sets the time in M/B/T you wish to move the objects by.
Preview - Preview allows you to examine the objects created before saying OK to move them.
Clicking the Audition button in the main window of the JET Creator application will open the Audition window. This is where the content author or application programmer can simulate the interactive playback as it may occur in the mobile application or game itself.
JET Audition Window
There are four main sections to the audition window. The left most section displays the available segments and their length in seconds. The middle section displays a running list of what segments are queued for playback and what their playback status is. The far right section displays the mute flags for the currently playing segment. The timeline section at the bottom is the same as in the main window. It displays the currently playing segment as well as a visual display of any event triggers associated with that segment.
The Audition window allows you to queue up any segment in any order for playback. To do this simply select the segment you wish to cue and hit Queue. That segment will appear in the queue window and start playing (if it is the first segment). Subsequently you can select any other segment or segments and cue them up for playback. As the segments complete playback, the next segment in the queue will begin playing. As is the other windows of JET Creator, you can mute, unmute, trigger event clips, etc. in realtime as each segment is playing back.
Specifically the buttons behave as follows:
Queue - loads the selected segment into the queue and starts playback
Cancel and Queue - cancels the currently playing segment before queueing the selected segment for playback
Cancel Current - cancels the currently playing segment in the queue and begins playback of the next segment
Stop - stops playback of all queued segments
Mute All - mutes all tracks in the current segment
Mute None - unmutes all tracks in the current segment
Original Mutes - sets the original mute flags for the current segment
The combination of these playback options allows an author or application programmer to audition any behaviour an interactive music application may encounter.
The JET Creator menus provide access to many of the parameters in the main window plus a few additional parameters.
The File Menu contains the following elements:
New - Creates a new JET Creator file (.jtc)
Open - Opens an existing JET Creator file
Save - Saves the currently opened JET Creator file
Save As - Saves the currently opened JET Creator file to a new file
Import Project - Imports a JET Creator archive (.zip)
Export Project - Exports a JET Creator archive (.zip)
Exit - Exits the application
The Edit Menu contains the following elements:
Undo - Undo will undo the last edit made
Redo - Redo will redo the last undo
Cut - Copy selected parameter into clipboard and Delete selection
Copy - Copy selected parameter into clipboard and keep selection
Paste - Paste selected parameter
The Edit Menu contains the following elements:
Properties - Brings up the JET Creator priorities window. This window allows you to set the following conditions for a given JET file:
Copyright Info - Contains copyright info to be inserted into JET file
Chase Controllers - Option to chase controllers (on/off). This should usually be ON.
Delete Empty Tracks - Deletes any empty
The Segments Menu contains the following elements:
Add Segment - Brings up the Segment window
Update Segment - Updates segment attributes
Delete Segment - Deletes the current segment from the Segment List
The Help Menu will contain at least the following elements:
JET Creator Help - will launch PDF help document or go to on-line help
About - JET Creator version number, SONiVOX info
Breaking a
Trigger events allow for the following:
Under the hood, JET uses standard MIDI CC
events to accomplish these actions and to synchronize audio. The controllers
used by JET are among those not defined for specific use by the
Controllers 80-83 Reserved for use by application
Controller 102 JET event marker
Controller 103 JET clip marker
Controllers 104-119 Reserved for future use
Controller 103 is reserved for marking
clips in a
For example, to identify a clip with a clip
ID of 1, the author inserts a
Figure 5: Synchronized Clip
In the figure above, if the JET_TriggerClip() function is called prior to the first controller event, Track 3 will be un-muted when the first controller event occurs, the first clip will play, and the track will be muted when the second controller event occurs. If the JET_TriggerClip() function is called after the first controller event has occurred, Track 3 will be un-muted when the third controller event occurs, the second clip will play, and the track will be muted again when the fourth controller event occurs.
Note: Normally, the track containing the clip is muted by the application when the segment is initially queued by the call to JET_QueueSegment(). If it is not muted, the clip will always play until Jet_TriggerClip() has been called with the clip ID.
Controller 102 is reserved for marking
events in the
Normally, JET starts playback of the next
segment (or repeats the current segment) when the
To avoid this problem, the author can place a JET end-of-segment marker (controller=102, value=0) at the point where the segment is to be looped. When the end-of-segment marker is encountered, the next segment will be triggered, or if the current segment is looped, playback will resume at the start of the segment.
The end-of-segment marker can also be used to allow for completion of a musical figure beyond the end of measure that marks the start of the next segment. For example, the content author might create a 4-bar segment with a drum fill that ends on beat 1 of the 5th bar – a bar beyond the natural end of the segment. By placing an end-of-segment marker at the end of the 4th bar, the next segment will be triggered, but the drum fill will continue in parallel with the next segment providing musical continuity.
Figure 6: End-of-segment Marker
The application may use controllers in this
range for its own purposes. When a controller in this range is encountered, the
event is entered into an event queue that can be queried by the application.
Some possible uses include synchronizing video events with audio and marking a
point in a


DJ Chuwy
Mashups
Mixcloud
previous
play
pause
next
stop
mute
unmute
shuffle
shuffle off
repeat
repeat off
Update Required
To play the media you will need to either update your browser to a recent version or update your
Flash plugin
.


Contracting parties: 6 total: Australia, Indonesia, Japan, Korea (Republic of), New Zealand, Taiwan.
Area: The entire geographical range of Southern bluefin tuna.
Date entered into force: 1994
FAO association: No.
FAO statistical area: 41, 47, 51, 57, 81.
Objectives: “…to ensure, through appropriate management, the conservation and optimum utilisation of the global SBT fishery. The Commission also provides an internationally recognised forum for other countries/entities to actively participate in SBT issues.”
Primary species: Southern bluefin tuna (Thunnus maccoyii).
The x-axis on the figure below represents current spawning stock biomass (SB2006) over spawning stock biomass at maximum sustainable yield (SSBmsy). The y-axis represents current exploitation rate (U2006) over exploitation rate that produces maximum sustainable yield (Umsy); For data sources, see Cullis-Suzuki and Pauly (2009).
.
Shown below is the time series of biomass of Southern bluefin tuna, the primary species under management of CCSBT; the red dashed line denotes the year of establishment of CCSBT (1994). For data sources see Cullis-Suzuki and Pauly (2009).


Images
Images are an essential part of any design system. There is a plethora of information available elsewhere with regards to image best practices. Here we will focus on the approach we’ve applied for the Delta Design System.
Aspect Ratio
In keeping with other features of this design system, we believe that images should be sized and cropped according to the Golden Ratio.
Responsive Images
Okay… here’s where it gets a little tricky. There are several different ways to render responsive images, and rendering responsive images is the right thing to do. With the Delta Design System, we’re currently only using a solution for retina and non-retina displays.
Adding a srcset
attribute to our
element enables us to present a high-resolution image only to retina devices and fall back to the low-resolution version for standard screens. The srcset
attribute points to a list of alternative image files. The 1x
tells the browser to display the lower-resolution image on standard-resolution screens. The 2x means that the higher-resolution image is used for retina screens. Older browsers that don’t understand srcset
fall back to the src attribute.
Important Guidelines
- Every

you add to your site needs to have analt
attribute. If the image is informational, set thealt
equal to a descriptive alternative for that image. - If the image is decorative or redundant to adjacent text, set
alt=""
, which conveys to assistive technology users that the image isn’t necessary for understanding the page. - Avoid using generic strings like photo, image, or icon as
alt
values, as they don’t communicate valuable content to the user. Be as descriptive as possible.
We will add more options for images in a later phase of development, including options for art direction.


{{- partial "head.html" . -}}
{{- partial "header.html" . -}}{{.content | markdownify}}
{{ if .button.enable }} {{ with .button }} {{.label}} {{ end }} {{ end }} {{ end }}| Multi-level soil moisture Sensors: Surface, target root zone & at drainage level. | |
| Sensor Nodes: Battery & Solar powered. | |
| Gateway cum Pump Controller: Local brain. | |
| Soil Moisture Potential Tables: Triggers for multiple drip irrigated crops. | |
| Multiple Connectivity modes: Wifi, GSM, NB-IoT, LoRa tech. | |
| Actuation: Multi-zone Relays for actuation of Water pumps. |


pure CSS menus
For some time now, I've had this idea that if one could apply :hover
to arbitrary elements, all kinds of possibilities would open up. Sure, we can do nifty stuff with hyperlink hovering, such as popup text and images, but to be able to apply hover styles to any element-- that would really be something.
So consider the box with the text "css/edge" near the top left of the page, or the list of "meyerweb" links on the right. If you have a browser that has advanced enough CSS2 support, you can hover over some of the links and get a popout menu. As you drill down, some of the links in those menus lead to popout submenus. And it's all driven by CSS and some nested lists. Absolutely no Javascript was used in the making of these menus.
No!
Yes! That's what happens when you have a rendering engine (Gecko, in this case) that permits hover styles on arbitrary elements. Okay, it also has to be good at positioning, but fortunately for us, Gecko's positioning code is up to the task.
Dig into the markup and the CSS. It's all there, and it's actually a lot less complicated than you might think. In both cases, the markup for the menus is nothing more complicated than some nested ul
elements. I just used id
hooks on each list so that I could give each list a very different look-and-feel. Try it out! Even better, thanks to the title
attribute, we can have "tooltip" expansions of the menu entries-- try it on any link in a "css/edge" submenu (in either menu).
Here's the foundation of this effect:
li ul {display: none;} li:hover > ul {display: block;}
Sprinkle a little positioning on top of that, so that the popout menus go where you want them, and you're in business. Frost on some borders, colors, et cetera, and you're stylin'.
How about other browsers?
In other CSS-aware browsers, like Internet Explorer, you'll see the toplevel links, and they'll work just fine. The popout menus won't work, that's all. Of course, this means that the browser is downloading the contents of the complete menu, but only able to display a small part of what it downloaded. This is in some respects unfortunate, but at least the basic menu will still function. And the amount of markup involved is probably a lot fewer characters than a similar Javascript-driven menu intended to serve a similar purpose.
(And if you're grumbling that you don't see why anyone would deploy a menu system that only worked in one browser, then you should see how many Javascript menus I deal with that don't work in more than one or two browsers-- usually because they're doing browser sniffing as if this were still 1998. But I digress.)
If the browser is too old to understand CSS, or doesn't support CSS because (for example) it's a text-mode browser like Lynx, then the user will get the entire menu as a set of nested lists. No problem.
It would also be possible to construct the selectors in the CSS so that the hiding of the submenus could only be understood by advanced browsers, thus giving the complete set of nested lists to any browser that wouldn't have been able to deal with the popouts. I didn't take this step for the demo, because it cluttered up the CSS. Besides, it just didn't seem like as much fun that way.
Acknowledgments
It was Porter Glendinning who gave me the idea to use nested lists instead of hopelessly convoluted nested div
s, and both Porter and Inigio Surguy devised the same basic technique independently of my efforts. Both their demos (Porter's, Inigo's) came to my attention just after I announced the first draft of this demo on css-discuss, and in both cases gave me some ideas to flesh this demo out a little more fully. Many thanks and kudos are due to both!


|
| int | genmmd_ (int *neqns, int *xadj, shortint *adjncy, shortint *invp, shortint *perm, int *delta, shortint *dhead, shortint *qsize, shortint *llist, shortint *marker, int *maxint, int *nofsub) |
| |
| int | slu_mmdint_ (int *neqns, int *xadj, shortint *adjncy, shortint *dhead, shortint *dforw, shortint *dbakw, shortint *qsize, shortint *llist, shortint *marker) |
| |
| int | slu_mmdelm_ (int *mdnode, int *xadj, shortint *adjncy, shortint *dhead, shortint *dforw, shortint *dbakw, shortint *qsize, shortint *llist, shortint *marker, int *maxint, int *tag) |
| |
| int | slu_mmdupd_ (int *ehead, int *neqns, int *xadj, shortint *adjncy, int *delta, int *mdeg, shortint *dhead, shortint *dforw, shortint *dbakw, shortint *qsize, shortint *llist, shortint *marker, int *maxint, int *tag) |
| |
| int | slu_mmdnum_ (int *neqns, shortint *perm, shortint *invp, shortint *qsize) |
| |
Copyright (c) 2003, The Regents of the University of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from U.S. Dept. of Energy)
All rights reserved.
The source code is distributed under BSD license, see the file License.txt at the top-level directory.


RTRIM Function
The RTRIM function trims a specified set of characters from the end of a string.
Syntax
RTRIM( string, trim_chars )
Arguments
- string
-
The string column or expression to be trimmed.
- trim_chars
-
A string column or expression representing the characters to be trimmed from the end of string.
Return Type
A string that is the same data type as the string argument.
Example
The following example trims the characters 'Park' from the end of VENUENAME where present:
select venueid, venuename, rtrim(venuename, 'Park') from venue order by 1, 2, 3 limit 10; venueid | venuename | rtrim --------+----------------------------+------------------------- 1 | Toyota Park | Toyota 2 | Columbus Crew Stadium | Columbus Crew Stadium 3 | RFK Stadium | RFK Stadium 4 | CommunityAmerica Ballpark | CommunityAmerica Ballp 5 | Gillette Stadium | Gillette Stadium 6 | New York Giants Stadium | New York Giants Stadium 7 | BMO Field | BMO Field 8 | The Home Depot Center | The Home Depot Cente 9 | Dick's Sporting Goods Park | Dick's Sporting Goods 10 | Pizza Hut Park | Pizza Hut (10 rows)
Note that RTRIM removes any of the characters P
, a
,
r
, or k
when they appear at the end of a VENUENAME.


My Work
Accelerate
WordPress, HTML5, CSS3, PHP
For this project, I was assigned the task of coding a WordPress theme based on web designs that were provided to me for Accelerate Marketing. This was a self initiated project courtesy of Skillcrush, where they provided source material that closely mirrored the experience of working directly with a client.
Unplugged Retreat
HTML5, CSS3, Git
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut nec pulvinar est. Ut posuere turpis ac fringilla auctor. Donec ultrices vulputate mauris, id molestie metus lobortis non. In rutrum vitae massa at vulputate. Aliquam ut posuere enim. Suspendisse elementum quam nec pellentesque porttitor.
Easy Bank
HTML5, CSS3, SASS, JavaScript, Git
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut nec pulvinar est. Ut posuere turpis ac fringilla auctor. Donec ultrices vulputate mauris, id molestie metus lobortis non. In rutrum vitae massa at vulputate. Aliquam ut posuere enim. Suspendisse elementum quam nec pellentesque porttitor.


Home
About
Chat Rooms
Sign In
Hi, {%if current_user.is_authenticated%}{{current_user.username}}! {%else%}Guest! In order to use the chatroom you need to Log In{%endif%}
Create room(nf)
{%for room in rooms%}
{{room.name}}
{%endfor%}


Data type for falsehood
Downside to busy airports
Eats audibly
Endlessly endure inner agony
Even-handed
Evolution of dalet
Fix or heal
Fluid customary unit
Funnily, both a rail and a loon
Guy off alone
Headgear outside around the end of time at a university
In chimpanzees, one becoming others' leader
Large medieval center around Pakistan's eastern border
Low point / a spoken farewell
Meat with backstrap
Noisy apparition
Offers having a ribbon topper
Origin of cosmic luck
Piglet store, maybe
Pirouetting garb
Primary verdicts in one's surgery
Put 2 and 2 together, say
Result of countering basketball official with swears
Sandiego's organization
Sneaky figure backing a wrongful act
Some of the smallest amphibians
Source of reverberations in a cave
Start to card and Parker
Steal a piece of eight from a sailing ship
Step back and jump
Talk at length about oneself
To root (out)
Vehicle intended for transportation back to Kansas
Visible on the surface
Weather phenomena that bring in the start of rainstorms


Focus on the input field, enter in some data, leave field, focus input field again, clear field, leave field.


We are here to answer any questions you may have about our company. Reach out to us and we'll respond as soon as we can.
No.2, Ln. 445, Sec. 3, Wenxin Rd., Beitun Dist., Taichung City 406, Taiwan (R.O.C.)
Tel：886-4-37038989
Fax：886-4-37038888
E-mail：sales@machinetools.net.tw


{% extends "horizon/common/_modal_form.html" %} {% load i18n %} {% load url from future %}
{% trans "You do not have permission to access the resource:" %}
{{ request.GET.next }}
{% url 'horizon:user_home' as home_url %}{% blocktrans %}Login as different user or go back to home page{% endblocktrans %}
{{ request.COOKIES.logout_reason }}


--- title: Welcome to the Sarkisov Research Group at the University of Manchester! layout: standard --- The mission of our group is to accelerate the deployment of efficient technologies for carbon capture, water purification, energy from waste heat and separations.


# CMOS SERDES generator
![serdes](images/serdes.png)
(This generator example is not maintained anymore. Please refer to Woorham`s example for the latest codes)
This section describes how to generate CMOS serdes building block layout templates.
## Install and launch 1. Set up BAG environment for the technology in use. This is usually done by cloning technology repo provided by BAG developers. For example, cds_ff_mpt environment can be set up by running following commands.
` $ git clone git@github.com:ucb-art/BAG2_cds_ff_mpt.git $ cd BAG2_cds_ff_mpt $ git submodule init $ git submodule update $ git submodule foreach git pull origin master `
- Set setting up files, run virtuoso and BAG.
3. Create an empty library called (tech)_logic_templates. For example, for cds_ff_mpt technology, the library name will be cds_ff_mpt_logic_template.
Run this command to generate logic layouts.
`python run laygo/generators/logic/logic_templates_layout_generator.py `
5. Open (tech)_logic_templates library and check if cells are generated.
![logic_lib](images/logic_lib.png)
Run this command to generate a serializer layout.
`python run laygo/generators/serdes/serdes_layout_generator.py `
## Parameterizations
In laygo/generators/serdes/serdes_layout_generator.py, there are 2 parameters for serializer, ser_m**(serializer gate sizing) and **ser_num_bits. Users can try different numbers and regenerate the layout.
The figure shown below is for ser_m=4, ser_num_bits=8.
![serdes](images/serdes_8.png)
The figure shown below is for ser_m=2, ser_num_bits=16. You can see the number of rows is increased due to the the increased serialization ratio.
![serdes16](images/serdes_16.png)


Hi! Our coronavirus disease self assessment scan has been developed on the basis of guidelines from the WHO and MHFW, Government of India. This interaction should not be taken as expert medical advice. Any information you share with us will be kept strictly confidential.
Covid-19 ChatBot
How old are you?
Covid-19 ChatBot
Are you experiencing any symptoms.
Covid-19 ChatBot
Please select your travel and exposure details
Covid-19 ChatBot
Do your symptoms progressed over the last 48 hrs?
Covid-19 ChatBot
Do you cough Frequently?
Covid-19 ChatBot
Do you have shortness of breath?
Covid-19 ChatBot
I’m analyzing your answers…
Covid-19 ChatBot
Covid-19 ChatBot
1. Regularly and thoroughly clean your hands with an alcohol-based hand rub or wash them with soap and water.
2. Maintain at least 1 metre (3 feet) distance between yourself and others.
3. Avoid going to crowded places.
4. Avoid touching eyes, nose and mouth.
5. Make sure you, and the people around you, follow good respiratory hygiene.
6. Stay home and self-isolate even with minor symptoms such as cough, headache, mild fever, until you recover.