We Meditate.
Meditation is simply to know. “Know” in this sense is not knowing in our thoughts or knowing from reading, listening, or thinking but knowing as in to experience, be aware of, or be mindful of.
What do we know in meditation?
The objects that we must know in meditation are ourselves. The self can be divided into two main parts: the mind and the body.
However, it could further be separated it into five parts which are..
- Body
- Consciousness
- Knowledge
- Thoughts
- Feeling
These are the objects of meditations.
What do we do once we are mindful of our body, consciousness, knowledge, thoughts, and feeling?
Nothing. Simply by being mindful of ourselves is enough. This might sounds very strange in this age where one has to always do more or always take a more active stance in achieving something. But this is not the case for meditation.
What is the correct way to know in meditation?
Know objectively as is. Without any need to change or to desire how our body, consciousness, knowledge, thoughts, and feeling should or should not be. If you are upset, know that you are upset. If we have a stomach ache, know that we have the stomach ache. This is how we develop our mindfulness.
Why should I develop my mindfulness? What is the purpose of meditation?
The purpose of meditation is to allow the mind to see its own reality. Our life is full of ups and downs, positive emotions and negative emotions, good thoughts and bad thoughts, birth and death, and of knowledge of what is “good” and “evil”.
How do we live and navigate in the world which is full of these dualities of life is the real question that one must know the answer to live a happy life.
When life is not going the way we want we can always say to ourselves that, “life is uncertain” or that “it will soon pass.” But do our hearts really accept this fact? Even with the knowledge that life is uncertain, we still suffer. For this reason, knowing by knowledge is not enough. What we need is to know life by heart. This is why meditation is needed as the tool for our hearts to come to know truth.
By allowing our hearts to see the dualities of life, we can see that life with its ups and downs has three characteristics:
- Everything is impermanent.
- Nothing lasted.
- Reality has nothing to do with what we want, but it has everything to do with the natural law of cause and effect. (For a more detailed explanation, click here.)
Meditation is how one comes to understand reality. It is how our hearts learn about how everything comes and goes, how all must inevitably progress from birth to death, and how the world is not about what we want but about the absolute law of cause and effect. These are the truth that our hearts will come to see for itself just by being mindful.
Once the hearts could come to understand the truth of life. Life becomes easier to live and harder for it to suffer. Like learning how to ride a horse, if you do not know how, riding becomes a nightmare. And often times than not, the horse rides you more than you ride the horse. Life is very much the same. This is why one must learn life to live it. And meditation is how.
Types of Meditation
1. Meditation in Daily Life
The most important type of meditation is not one in which most people believe. Many have the idea of meditation as sitting down, closing our eyes, and watch our breathing. But for meditation to be effective it must be practical in our daily life.
And there are two ways one could develop mindfulness in our daily life.
- Being mindful of our mind
- Being mindful of our body
Our mind consists of our consciousness, knowledge, thoughts, and feelings. Consciousness's only task is to know. Knowledge is what we know. Thoughts are our cognitive thinking. And feeling is... feeling! (However, it could be further generalized into three types of feelings: positive, negative, and neutral.)
We develop our mindfulness by noticing our thoughts and feelings. When a thought takes our mind from places to places we know our mind is wandering. When we are happy, we know that we are happy. When we are sad we know that we are sad. This is all it takes to develop mindfulness. (Really?) Really!
In our daily life, we can develop our mindfulness by knowing our bodies in the present moment like when we are breathing, walking, eating, sitting, and etc. Simple right? Just know our bodily movement through out the day and we are all set!
In short, meditation in daily life is to know our body, consciousness, knowledge, thoughts, and feelings.
- How much daily meditation is enough?
All day is enough. True practictioners of mindfulness begin their practice starting from the moment they wake up until the moment they go to bed.  They are mindful of all their positive or negative thoughts and emotions through out the day. The practice of mindfulness is easy; but to practice it consistently through out the day is not. Slowly build your mindfulness in daily life until it becomes a second-nature.
2. Sitting and Walking Meditation
- Sitting Meditation
Find a suitable spot for sitting meditation. Preferably any place that is quiet and give you a sense of peace and tranquility.
Sit in a comfortable position. It is not required for you to sit on the floor. Sitting on a chair would do. But I would recommend that the chair should not be too comfortable because it would make you fall asleep!
You can begin noticing your out breath and in breath with your eyes open or closed. If you easily get sleepy while doing your sitting meditation then it would be good to start with your eyes open and just notice the in and out breath before closing your eyes once you feel more concentrated.
Continuosly be mindful of the breath. If you mind wanders, simply bring it back to the breath and continue.
- Walking Meditation
Sitting meditation is ultimately to be mindful of our in breath and out breath. Let's first begin with the steps:
These are the steps to sitting meditation which can seem pretty simple but once you are into the practice and actuality of doing it, it is not. So here are some tips.
Quick Tips on Sitting MeditationMeditation is not about control nor is it about letting the mind runs loose. The trick is to find the perfect balance between controlling and not. To know the breath by being not too tight and not too loose. Sitting meditation is like holding a chick. If you hold it too loosely it runs away. If you hold it too tightly, the chick suffocates. If you find yourself feeling tight, stiff, having a headache, or finding it difficult to just breathe during or after meditation then it is a clear sign that you are exerting too much control. If you are sleepy, find your mind wandering from places to places without being able to come back to the breath, then it might be possible that you are too loose. Learning sitting meditaiton is like learning how to ride a bike. It will take time and experience to adjust and know your own balance. And practice is key to finding it.
Since my practice in walking meditation has been trained from the Theravada Buddhist tradition. I want to offer what I know from my own experience. So follow the links below to learn about how as well as why we do walking meditation. (Make sure you turn on the subtitle.) This knowledge will also aid you in your sitting meditation since it pretty much has the same concept.
- How much sitting/walking meditation is enough?
Twice a day. I would suggest to make this into a habit by chaining it with some daily routine you have been doing.  It does not need to be a hour long session. In fact one minute would do. But the important thing is to not lose the routine. Once you keep the routine for around 3 weeks, the habit of meditating will stick with you.
Conclusion
I can only show you the door. But you are the only who has to walk through it.
All in all, I could talk all day about how you should meditate; but in the end you have to do it. Only through meditation will you find out for yourself what meditation actually is. You can’t learn how to ride a horse or swim from just reading a textbook. You must do it to learn it. Life is where we can learn about life’s truth. This is why meditation is defined as the process of knowing oneself. Enough talking and start doing!
Recommended readings about “Meditation”:
-
Why Meditation?
- Learn goals behind the art of meditation, click here
- If you are curious about why meditation is important to this world, click here
- Click here to learn more about my experience with meditation.
Why Meditation Matters to The World?
What I Have Received from Meditation as a Long-Time Practitioner?
Posted with : Practice of True Happiness


De Bruyne: A loss would not be 'season-defining'
Cape Town - Manchester City midfielder Kevin De Bruyne insists "there's no way the season would be over" if Liverpool were to win Sunday's top-of-the-table clash at Anfield.
City are seeking a third successive Premier League title but they have some ground to recover if they are to make it a hat-trick of domestic crowns.
The defending champions are six points behind pacesetters Liverpool ahead of Sunday's meeting at Anfield.
A victory would see City move up to second and within three points of the Reds, while defeat would leave them nine points off the pace and in fourth spot after Leicester and Chelsea both won on Saturday.
De Bruyne knows a loss would put a huge dent in his side's title aspirations but he says even if they fail to get a result on Merseyside they will not be out of contention.
"If they were to win, then the gap is big, but it's not season-defining," De Bruyne told the club's official website.
"There's no way the season would be over, there's still so many games after with a lot of points to play for, but obviously if you have a nine-point gap then they'd be very happy and for us there would be more pressure."
Chelsea and the Foxes have enjoyed excellent starts to the season and both have to considered as title contenders at this stage, with the two sides five points behind Liverpool.
De Bruyne refused to rule out either keeping the pace and battling for Premier League glory but the Belgian international believes that ultimately the title race will come down to a fight between his side and the Reds, who he sees as City's "biggest threat".
City are unbeaten in six games across all competitions and are seeking a fourth Premier League win in a row, while Liverpool remain unbeaten in the league and have picked up 31 points from a possible 33 ahead of Sunday's huge fixture at Anfield.
- TEAMTalk


To Gillian On Her 37th Birthday (1996) A film review by James Berardinelli Copyright 1996 James Berardinelli
RATING (0 TO 10): 6.0 Alternative Scale: **1/2 out of ****
United States, 1996 U.S. Release Date: 10/18/96 (limited), 10/25/96 (wide) Running Length: 1:32 MPAA Classification: PG-13 (Profanity, mature themes) Theatrical Aspect Ratio: 1.85:1
Cast: Peter Gallagher, Claire Danes, Michelle Pfeiffer, Kathy Baker, Wendy Crewson, Bruce Altman, Laurie Fortier, Freddie Prinze Jr. Director: Michael Pressman Producers: Marykay Powell and David E. Kelley Screenplay: David E. Kelley based on the play by Michael Brady Cinematography: Tim Suhrstedt Music: James Horner U.S. Distributor: Triumph Films
It's bad enough to be ill on your 37th birthday, but Gillian (Michelle Pfeiffer) is considerably worse off. She has been dead for two years, but even that impediment doesn't stop her from showing up for the party. The reason she's still around is because her husband, David (Peter Gallagher), can't let go. Theirs was a near-perfect love, and, since her death, he hasn't been able to reach a state of emotional equilibrium. So he leads the life of a recluse, doing his best to care for his teenage daughter, Rachel (Claire Danes), while steadfastly refusing any relationship that looks like it could lead to a romantic entanglement. When he gets especially lonely -- which is almost every day -- Gillian's apparition appears to him.
Hollywood is often at its worst when attempting to deal seriously with issues of life and death. Since most major motion picture studios are most comfortable making "feel good" movies, they become skittish when faced with a script that confronts death. As a result, instead of employing the subtlety and keen insight which would generate powerful results (see DEAD MAN WALKING for an example), directors typically resort to melodrama and manipulation. That's one of the problems with TO GILLIAN ON HER 37TH BIRTHDAY. The subject matter is emotionally- wrenching, but it's handled unevenly, with the accent on trying to make the audience cry rather than feel.
To its credit, there are times when TO GILLIAN gets things right. As a likable man who can't quite cope with his devastating loss, David is consistent and believable. And, for the most part, his scenes with Gillian are nicely-handled. Less sure is his relationship with his daughter.  Unfortunately, there are other instances, such as when David doesn't approve of a boyfriend, that play like scenes from a TV sitcom.
Personally, I would have preferred a lot more interaction between David and Rachel, and a few more scenes with Gillian, since Michelle Pfeiffer fits nicely into the role. Instead, we're given a host of secondary characters -- Gillian's older sister, Esther (Kathy Baker); her husband, Paul (Bruce Altman); a flirtatious neighborhood girl named Cindy (Laurie Fortier); and Kevin Danford (Wendy Crewson), a woman Paul and Esther have set up as a date for David. All of these characters converge on David's Nantucket home for a few days of singing '70s songs and building sand castles. It's "Gillian's Weekend" -- the anniversary of both her birth and her death.
TO GILLIAN wants to use Paul and Esther as a contrast to David and Gillian, but it never really works. Esther and Paul's relationship remains half-developed, and she in particular comes across as a bitter, jealous person who insists that there's something seriously wrong with David because he fantasizes about seeing his dead wife. Meanwhile, Kevin, David's would-be-blind date, is superfluous. The film wouldn't have changed one iota without her. Performances also factor into how we feel about the characters -- Kathy Baker isn't very good, but both Gallagher and Danes are.
As directed by Michael Pressman and scripted by David E. Kelley, TO GILLIAN ON HER 37TH BIRTHDAY has the erratic feel of a play adapted for the screen, which it is (Michael Brady's award-nominated production debuted on stage 11 years ago). The plot jumps around and there's a feeling that certain relationships should be more complex than what we're seeing. There are times when this movie gets on track and delivers a series of surprisingly effective scenes, but it doesn't sustain the momentum. In fact, the likability of the main characters makes this inconsistency all the more frustrating.
I've seen some comparisons between TO GILLIAN and GHOST, but, aside from the "presence" of a dead lover, there's not much connection -- this is a more somber, less metaphysical story. And, despite its various problems, TO GILLIAN ON HER 37TH BIRTHDAY occasionally touches a core of emotional honesty that makes you wonder how much better it could have been had all the extraneous characters been jettisoned.
- James Berardinelli e-mail<EMAIL_ADDRESS>ReelViews web site: http://www.cybernex.net/~berardin
"We go away from our parents in youth and then we gradually come back to them; and in that moment, we have grown up." -- Ingmar Bergman
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Prompt:Write a blog post that describes and compares arrays and hashes.
Arrays and hashes are both ways of storing and organizing code objects. Arrays are ordered collectios of objects. You can select objects in an array based on a consistent numerical index. Any object can be stored in an array including other arrays and hashes. While both arrays and hashes store information, they do so in different ways. Another way of thinking about it is that arrays are hashes that happen to store consecutive integers.
Hashes meanwhile store objects in pairs. Hashes point from one object (a key) to another (a value) and vice-versa. Hashes do not necessarily need to be ordered and unlike arrays, do not have specific integers assigned to their place in the collection. Hashes may be easier to manipulate because they have word assignments ralted to the information you are organizing. When dealing with large Arrays, it may be more beneficial to use hashes to make it easier to find the objects you are looking for.
Lets look at an array that organizes abbreviations of New England states, because sometimes we need to remember the one time Massachusetts comes before Maine:
array = ["CT", "MA", "ME", "NH", "RI", "VT"]
Based on the organization of this array, the value "CT" is assigned the integer 0 because it is the zeroeth integer in the array.
You would "call" the abbreviation "MA" by typing in this code:
puts array[1]
But how would a hash look if we wanted to, say, organize New England states by their corresponding abbreviation? As I mentioned before Hashes include both a key (similar to an index in Arrays) and a value assigned to the key.
hash = {"Connecticut"=>"CT",
"Massachusetts"=>"MA",
"Maine"=>"ME"}
To call on specific keys and values in a hash, you would set up your code like this:
hash['Massachusetts']
This calls the value for the key "Massachusetts". If we wanted to add another state and its abbreviation value, it would look like this:
hash["Maryland"] = "MD"
As you can see, if we had a list of all 50 states and their abbreviations, it could be too confusing to think "which integer is assigned to the state of Nebraska?"
Ultimately, it's your choice whether to use Arrays or Hashes. As you become more comfortable with them and realize their full capabilities, you can decide which one to use for each situation.


It is not envisaged that the average C programmer will ever need to be directly concerned with the details of how a system interfaces to the Runtime Link Manager. This capability is intended primarily for use by a systems level programmer who is trying to interface a new programming language to the RLM.
The calls that the RLM supports allow all phases of its operation to be directly controlled. This should make it easy to interface a new system to the RLM.
If you are a C programmer using the C68 system, then you do not have to worry about this aspect of the RLM at all. The necessary calls to link C68 programs to the RLM are issued automatically from the C startup module if you specified that you wanted to use RLL libraries when you built your program.
The RLM is implemented using the THING system. The calls to the RLM therefore use the standard mechanisms for interfacing to the THING system. Some systems such as SMSQ, SMSQ/E, SMS2 or Atari QL Emulators with Level E drivers have built in support for the THING system. On other systems it needs to be loaded explicitly. It is worth noting that if your system has support for the Hotkey system, then you do already have THING support loaded (this means that users of QPAC2 will always have such support loaded). If the system does not satisfy any of the above criteria then the THING support code needs to be loaded explicitly. C68 users will have the THING_REXT file on the RUNTIME 2 disk to provide such support.
If you are going to write code that interfaces to the RLL or RLM at this level, then you should use the standard include files provided.
For C programmers, this is done using a statement of the form:
#include <rll.h>
while for assembler programmers the equivalent is
include rll_in
These include files are themselves used internally within th e components used to implement the RLL system, so using them in your own code will ensure consistency.
The first thing that one has to do is to check that the RLM is actually loaded into memory, and if so at what address. This is done by using assembler of the form:
rlmname dc.b 0,3,"RLM",0
rlmaddr dc.l 0
rlmver dc.l 0
moveq #sms.uthg,d0 ; Use THING call
moveq #-1,d1 ; this job
moveq #-1,d3 ; infinite timeout
lea rlmname$pc),a0 ; name of THING
bsr _ThingTrap ; ... do it
tst.l d0 ; did it work?
bne suicide ; ... NO, abandon
move.l a0,rlmaddr ; save address
move.l d3,rlmver ; save version
In the above example, the _ThingTrap
routine
is used to invoke the sms.uthg
system call.
This is because on systems that have direct operating support
for THINGS, the relevant operating system calls are available
as TRAP #1 calls, while on other systems these calls have to be
performed via a vector. The routine _ThingTrap
is
a way of automatically using the TRAP #1 call if it is available,
or using the vector method otherwise - but in both cases passing
exactly the same parameters.
The source of the _ThingTrap
routine is provided as
part of the source of the C68 LIBC_A libraries.
The calls to the RLM are made with a value in d0 indicating the operation required, with any additional parameters passed on the stack in C style. The parameters passed for each operation type will be as defined for that particular operation.
In assembler, a typical call sequence will be something of the form:
.... set up any parameters required
moveq #OperationCode,d0
move.l rlmaddr$pc),a0
jsr 12 $a0)
lea ??$sp),sp ; remove stack parameters
tst.l d0 ; did it work?
bne ??? ; ... NO, do something
Note that it is the responsibility of the calling code to tidy the stack and remove the parameters that were passed on the stack when the call has completed.
When you have finished using the RLM, then you should immediately free it.
In Assembler this would look like:
moveq #sms.fthg,d0
moveq #-1,d1
lea rlmname,a1
jsr _ThingTrap
The C68 standard C library contains routines which simplifies the handling of the RLM. The above complexities of finding, calling and releasing the RLM are hidden behind a single function call. This simplified interface does the following every time:
The simplified assembler interface is provided by the CallRLM()
function. This used by as follows:
.... set up parameters for the RLM call
moveq #OperationCode,d0 ; Set the operation type
jsr CallRLM ; go and do it
lea ??$sp),sp ; remove stack params
tst.l d0 ; did call work?
bne ??? ; ... NO, do something
The interface for the C programmer consists of a named call
corresponding to each of the possible RLM functions (which
are then mapped internally in the library onto the
CallRLM()
function mentioned above).
If you are going to use these versions of the calls,
then the C program should include a statement of the form:
#include <rll.h>
to get the appropriate prototype definitions included. You can then simply use statements such as:
RLM_SetDebugDir("ram1_");
from within the C program. This C interface is also, of course, available to the assembler programmer. The full definition of all these calls in C terms follows later in this document.
Note, however, that a program cannot issue a call to the RLM to do relocation on itself using this simplified interface. This is because the C compiler does not produce position independent code, so until the relocation has happened no C library routines can be called.
In operation the Runtime Library Manager will be installed as a shareable utility thing with a single entry point at offset %10 relative to its Thing Header. The first parameter must always be a word containing an operation code to indicate the call function required. A QDOS/SMS error code is returned in d0.l. Parameters are passed on the calling jobs stack. Calling jobs should have at least 1000 bytes of stack space available + any stack space used by RLL init routines $thus maximum total usage 2000 bytes).
The RLM is initialised by the conventional LRESPR call. The SuperBasic command INIT_RLM is also linked in to permit the user to re-link the RLM in the event of accidental Thing removal. The RLM is not currently ROMable as it includes C code that needs runtime relocation. It could be rewritten in assembler to remove this restriction.
SuperBasic extensions are provided to permit the user to change defaults etc. This interface was described in Section 2 of this document. The low-level assembler calls to change the global environment of the RLM are intended for front-end programs and not client jobs requiring linking.
Libraries can be loaded explicitly by the user or as required by the RLM $and automatically removed when not in use). A default library directory is defined internally to the RLM as the primary search path for RLLs. In addition the LIB_ subdirectory of the PROG_USE directory, and the DATA_USE directories would also be searched.
The following gives the details of the calls that are supported by the RLM.
The operation codes available are:
| Operation Code | C function name | Description |
|---|---|---|
| 0 | RLM_LinkCode | Link Code to RLL system |
| 1 | RLM_CheckRLL | Check if a RLL is loaded |
| 2 | RLM_LinkRLL | Link code to a single RLL |
| 3 | RLM_UnlinkRLL | Unlink code from a single RLL |
| 4 | RLM_LoadLib | Load a RLL |
| 5 | RLM_SetTimeout | Set Default timeout delay |
| 6 | RLM_SetLoadMode | Set Interactive Reporting mode |
| 7 | RLM_SetLoadDir | Set Default Library Directory |
| 8 | RLM_SetDebugDir | Set Debug Directory |
| 9 | RLM_SetDebugMode | Set Debug Mode |
| 10 | RLM_ReadSettings | Read RLM global settings |
| 11 | RLM_RelocLD | Relocate code using C68 compatible relocation |
| 12 | RLM_RelocGST | Relocate code using GST compatible relocation |
| 13 | RLM_LibrarySymbol | Get the address of a symbol within the given RLL |
| 14 | RLM_ProgramSymbol | Get the address of a symbol used by the current program |
The above calls are each described in detail in the remainder of this section.
RLM_LinkCode | Link Code to RLL | (d0 = 0) |
int RLM_LinkCode(char *, BSS_HEADER *, jobid_t, chanid_t);
| long | Address of start of code to be linked in |
| long | Address of RLL BSS area. In practise only the BSS_HEADER, RLIB and XREF areas need to be present at this stage |
| long | Job Id of the owner |
| long | Channel ID for debug reports. A value of -1 causes a new console channel ID to be opened |
| 0 | Success |
| Other | QDOS/SMS error code. |
The list of RLLs required is taken from the RLIB section of RLL BSS area of the calling code. If any RLLs are specified by the calling program that have not already been loaded, then an attempt will be made to load them.
The list of addresses in the calling program that need linking are taken from the XREF part of the BSS area.
It is possible for one job to link the code of another by passing the job ID of the code owner. If this is done steps must be taken to guard against the unexpected removal of the code owner, for example the calling job being owned by the code owner.
Note that this call does not do program relocation of the calling program. The RLM can, however, be called to do this if needed.
RLM_CheckRLL |
Check if a RLL is loaded |
(d0 = 1) |
RLL_HEADER * RLM_CheckRLL (char *);
| long | Address of the name of the RLL that we want to check to see if it is already loaded into memory. This is passed as a C style string. |
| +ve | Success. The value returned is a pointer to the RLL Header. |
| 0 | RLL is not loaded. |
| -ve | QDOS/SMS error code. |
The RLL Header can be used to check things such as the version number, or locate any of the other control areas.
RLM_LinkRLL | Link to a specified RLL | (d0 = 2) |
int RLM_LinkRLL (char *, char *, BSS_XREF *, chanid_t);
| long | Address of the name of the RLL to be linked in. |
| long | Address of start of code to be unlinked in. |
| long | Address of BSS_XREF area. |
| long | Channel ID for debug reports. A value of -1 causes a new console channel ID to be opened. |
| 0 | Success |
| Other | QDOS/SMS error code. |
RLM_LinkCode()
call would
be used instead to link all RLL(s associated with a particular program.
It is intended for use by programs that want to be able to dynamically
load and unload RLL(s at runtime. It carries out the actual process
of linking external references that are in the caller with the relevant
locations in the RLL.
If the RLL to be used has any dependencies on other RLLs, then these will also be automatically loaded. However no references from these extra RLLs will be used to satisfy the ones listed in the BSS_XREF area passed to this call.
It is possible for one job to link the code of another by passing the job ID of the code owner. If this is done steps must be taken to guard against the unexpected removal of the code owner, for example the calling job being owned by the code owner.
Note that this call does not do program relocation of the calling program.
RLM_UnlinkRLL |
UnLink Code from a specified RLL |
(d0 = 3) |
int RLM_UnlinkRLL (char *, char *, BSS_XREF *, chanid_t);
| long | Address of the name of the RLL to be unlinked from |
| long | Address of start of code to be unlinked from the RLL |
| long | Address of BSS_XREF area |
| long | Channel ID for debug reports. A value of -1 causes a new console channel ID to be opened. |
| 0 | Success |
| Other | QDOS/SMS error code |
RLM_LinkRLL()
call.
It will unlink a specified program from the given RLL.
If the unload timeout for this RLL is reached, then it will
be automatically unloaded. Similarly if there are any dependent
RLLs that reach their unload timeout, then they would also be
unloaded.
This call is not expected to be used very often as in most cases
the RLM_LinkCode()
call
would be used instead to link all RLL(s) associated with a
particular program, and they would never be explicitly unlinked.
Instead the program would terminate itself, and the RLM would
automatically tidy up the state of the loaded RLLs as a result.
The main purpose of this call is to provide a method of dynamically linking in different RLLs at runtime according to some external criteria. This system needs to be used with great care as any attempt to execute code that has not yet been linked to its target RLL is certain to cause a program to crash, and is quite likely to crash the whole system.
It is possible for one job to unlink the code of another by passing the job ID of the code owner. If this is done steps must be taken to guard against the unexpected removal of the code owner, for example the calling job being owned by the code owner.
Note that the default action of the LD linker is to set up the program so that the BSS_XREF area is to be re-used as UDATA (Unitialised Data) purposes once a program has finished its initialisation phase. If you want to make the UDATA area start after the XDEF area then you need to make sure you use the -keepxref parameter to LD.
RLM_LoadLib |
Load a RLL |
(d0 = 4) |
int RLM_LoadLib (char *, timeout_t, chanid_t);
| long | Address of a zero terminated string that is the name of the RLL to be loaded |
| word | The timeout value to be used. A negative value means make permanently resident and only removable by manual action |
| long | The channel ID to be used for reporting status |
| 0 | Success |
| Other | QDOS/SMS error code |
RLM_SetTimeout | Set Default Timeout Value | (d0 = 5) |
int RLM_SetTimeout (timeout_t);
| word | New timeout value |
| 0 | Success |
| Other | QDOS/SMS error code |
It is also normally inadvisable to specify too small a value for this timeout. If you do, you may find that the library is continually being unloaded just before you are about to use it again.
RLM_SetLoadMode | Set Interactive Reporting status | (d0 = 6) |
int RLM_SetLoadMode (short);
| word | Set Reporting status. 0 = off, 1 = on |
| 0 | Success |
| Other | QDOS/SMS error code |
RLM_SetLoadDir | Set Default Library Load Directory | (d0 = 7) |
int RLM_SetLoadDir (char *);
| long | Address of a zero terminated string (C style) that is the new name to be used |
| 0 | Success |
| Other | QDOS/SMS error code |
RLM_SetLoadDir()
function.
RLM_SetDebugDir | Set Debug Directory
(d0 = 8) |
int RLM_SetDebugDir (char *);
| long | Address of a zero terminated string that is the new name to be used. |
| 0 | Success |
| Other | QDOS/SMS error code |
RLM_ SetDebugMode | Set Debug Mode | (d0 = 9) |
int RLM_SetDebugMode (short);
| word | Debug mode. 0 = off, 1 = on |
| 0 | Success |
| Other | QDOS/SMS error code |
RLM_ReadSettings | Read RLM Settings | (d0 = 10) |
void RLM_ReadSettings (RLM_READVALUES *);
| long | Address of a structure that will be used to return the values of the RLM internal variables. |
| 34 bytes | Name of the default debug directory |
| 34 bytes | Name of the default directory for loading RLLs |
| Word | Default timeout for unloading RLLs that are dynamically loaded. |
| word | Debug Mode status |
| word | Report Mode status |
RLM_RelocLD | Relocate using C68 relocation | (d0 = 11) |
void RLM_RelocLD (char *, BSS_HEADER *);
| Long | Base address of the code to be relocated. |
| long | Address of the BSS area for the code to be relocated |
If the processor is a 68020 or better, then the System Variable that controls hardware FPU support (at offset $d0) is examined. If this not set, then a check will be made to see if hardware FPU is present. The System Variable will then be set to disable checks if not found, and to use hardware FPU if it is found.
If the processor is a type that supports caches (i.e. a 68020 or better), then the current cache state will be read; the caches disabled while the relocation takes place; and then the original cache state restored.
RLM_RelocGST | Relocate using GST relocation | (d0 = 12) |
int RLM_RelocGST (char *, long *);
| long | Base address of the code to be relocated. |
| long | Address of the BSS area for the code to be relocated |
RLM_RelocLD()
routine, processor type will be detected, hardware FPU will be
detected and caches handled if appropriate.
Note that it is assumed that all locations that need relocation are of type long. No provision is made for any shorter data types.
RLM_LibrarySymbol | Get library symbol address | (d0 = 13) |
char * RLM_LibrarySymbol(char * symname, char * libname
| long | Name of the symbol to find as a C string |
| long | Name of the library to search |
| 0 (NULL) | Symbol (or library) not found |
| Other | Address of the symbol. |
RLM_ProgramSymbol | Get Program symbol address | (d0 = 14) |
char * RLM_ProgramSymbol(char *name);
| char * name | Name of the symbol to find as a C string |
| 0 (NULL) | Symbol not found. |
| Other | Address of the symbol |


Dialogs are windows popped up by a script to provide or request additional information. Dialogs are generally implemented with the 'Toplevel' window object.
Tkinter comes with a collection of precoded (modal) dialog windows and they are called 'standard dialogs' or 'common dialogs'.
# dialog1.py import tkinter as tk # Py3 from tkinter import messagebox root = tk.Tk() def callback(): if messagebox.askyesno("Verify", "Do you really want to quit?"): messagebox.showwarning("Yes", "Quit not implemented") else: messagebox.showinfo("No", "Quit has been cancelled") button1 = tk.Button(root, text="Quit", command=callback) button1.grid(sticky=tk.EW) button2 = tk.Button(root, text="Spam", command=lambda: messagebox.showerror("Error", "Error message")) button2.grid(sticky=tk.EW) root.mainloop()
# The first group of standard dialogs is used to present information. messagebox.showinfo("Info", "Some info") messagebox.showwarning("Warning", "Warning message") messagebox.showerror("Error", "Error message") # The second group is used to ask questions. reply = messagebox.askquestion("Title", "Question?") # return yes/no reply = messagebox.askokcancel("Title", "Proceed?") # return True/False reply = messagebox.askretrycancel("Title", "Try again?") # return True/False reply = messagebox.askyesno("Print", "Print this report?") # return True/False reply = messagebox.askyesnocancel("Print", "Print this report?") # return True/False/None


#include <nn_ops.h>
Optional attribute setters for FractionalMaxPool.
Public attributes |
|
|---|---|
deterministic_ = false
|
bool
|
overlapping_ = false
|
bool
|
pseudo_random_ = false
|
bool
|
seed2_ = 0
|
int64
|
seed_ = 0
|
int64
|
Public functions |
|
|---|---|
Deterministic(bool x)
|
TF_MUST_USE_RESULT Attrs
When set to True, a fixed pooling region will be used when iterating over a FractionalMaxPool node in the computation graph.
|
Overlapping(bool x)
|
TF_MUST_USE_RESULT Attrs
When set to True, it means when pooling, the values at the boundary of adjacent pooling cells are used by both cells.
|
PseudoRandom(bool x)
|
TF_MUST_USE_RESULT Attrs
When set to True, generates the pooling sequence in a pseudorandom fashion, otherwise, in a random fashion.
|
Seed(int64 x)
|
TF_MUST_USE_RESULT Attrs
If either seed or seed2 are set to be non-zero, the random number generator is seeded by the given seed.
|
Seed2(int64 x)
|
TF_MUST_USE_RESULT Attrs
An second seed to avoid seed collision.
|
bool tensorflow::ops::FractionalMaxPool::Attrs::deterministic_ = false
bool tensorflow::ops::FractionalMaxPool::Attrs::overlapping_ = false
bool tensorflow::ops::FractionalMaxPool::Attrs::pseudo_random_ = false
int64 tensorflow::ops::FractionalMaxPool::Attrs::seed2_ = 0
int64 tensorflow::ops::FractionalMaxPool::Attrs::seed_ = 0
TF_MUST_USE_RESULT Attrs tensorflow::ops::FractionalMaxPool::Attrs::Deterministic( bool x )
When set to True, a fixed pooling region will be used when iterating over a FractionalMaxPool node in the computation graph.
Mainly used in unit test to make FractionalMaxPool deterministic.
Defaults to false
TF_MUST_USE_RESULT Attrs tensorflow::ops::FractionalMaxPool::Attrs::Overlapping( bool x )
When set to True, it means when pooling, the values at the boundary of adjacent pooling cells are used by both cells.
For example:
index 0 1 2 3 4
value 20 5 16 3 7
If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice. The result would be [20, 16] for fractional max pooling.
Defaults to false
TF_MUST_USE_RESULT Attrs tensorflow::ops::FractionalMaxPool::Attrs::PseudoRandom( bool x )
When set to True, generates the pooling sequence in a pseudorandom fashion, otherwise, in a random fashion.
Check paper Benjamin Graham, Fractional Max-Pooling for difference between pseudorandom and random.
Defaults to false
TF_MUST_USE_RESULT Attrs tensorflow::ops::FractionalMaxPool::Attrs::Seed( int64 x )
If either seed or seed2 are set to be non-zero, the random number generator is seeded by the given seed.
Otherwise, it is seeded by a random seed.
Defaults to 0
TF_MUST_USE_RESULT Attrs tensorflow::ops::FractionalMaxPool::Attrs::Seed2( int64 x )
An second seed to avoid seed collision.
Defaults to 0


Creating a Magic Lantern Project
This document discusses how to create a project in Magic Lantern Java2D
Studio. A project is created using the New Magic Lantern Java2D Project
wizard. The wizard is used to create a project in the Eclipse workspace, specifying
the Java Runtime Environment (JRE) that the title will be targeted for. The
wizard also helps the developer identify the Digital Workprint and Digital
Playprint configuration for the Magic Lantern title. To simplify title development,
the developer can use the wizard to select a title template to base his/her
application on. Finally, the new project wizard is used to specify the source
and destination locations for the application code and executable classes,
respectively. Library and project dependencies are also specified through
the new project wizard.
To create a Magic Lantern Project, do the following:
-
Select "
File->New->Project..."
from the main Eclipse menu toolbar. This will bring up a New wizard selection
dialog box (see Figure 2.1).
Figure 2.1: New Wizard Selection Dialog
- Select the "Magic Lantern" category
to list the Magic Lantern wizard selections.
Note: An alternative way to select
the New Magic Lantern Java2D Project wizard is to use the shortcut in
the Magic Lantern Studio Perspective. Figure 2.2 shows how to use this
shortcut.
Figure 2.2: Using Perspective Shortcut to Create a New Project
- Double-click on "Magic Lantern Java2D Project"
to select the New Magic Lantern Java2D Project wizard. Figure 2.3
shows the new wizard.
Figure 2.3: New Magic Lantern Project Wizard
- Type in the name of the project. For example, Figure 2.3 shows HelloWorld
being used. For this example, leave the rest of the configuration parameters
in thier default state. We will be targeting version 1.6 of the JRE.
- Select the "Next >" buton to continue.
The wizard proceeds to the next page, displaying the user interface for identifying
the name of the Magic Lantern Digital Workprint. If you wish to change the
name of the Digital Workprint, do so now. See Figure 2.4.
Figure 2.4: Magic Lantern Java2D Configuration Page - Digital Workprint
Note: The Rehearsal Player is not currently
available with this release of Magic Lantern. Selecting the "Add
Rehearsal Player" button will do nothing.
- Select the "Digital Playprint" tab.
Figure 2.5 shows the configuration options for mastering the title. In this
example, we will use the default mastering configuration.
Figure 2.5: Magic Lantern Java2D Configuration Page - Digital Playprint
- Select the "Templates" tab in the Java2D
Configuration Page. Notice that Simple template is already selected.
The Simple template is the simplest title that can be mastered for the Java2D
target. The title consists of a Stage with a single Set.
The Stage is implemented as a Java AWT Frame. The Simple title does not contain
any Actors. Executing the Simple title will display an empty window
(Java Frame).
Select the the HelloWorld template (See Figure 2.6).
The HelloWorld template generates a title capable of rendering a string, "Hello
World!". The HelloWorld title consists of a Stage, a Set, and a LabelWidget
Actor. The HelloWorld title also provides a LabelWidget Role for rendering
the text onto its Set.
Figure 2.6: Magic Lantern Java2D Configuration Page - Templates
- Select the "Next>" button to continue.
This will bring you to the final wizard page where you can configure the Java
build settings.
Figure 2.7: Java Settings Page
- To complete setting up your Magic Lantern Studio project, select "Finish".
This will create the project and master the template for the Java2D target.
The wizard will ask you if you wish to change perspectives from the Magic
Lantern Studio Perspective to the Java Perspective. Select "Yes"
to switch perspectives.
- The HelloWorld project should now appear in the Package Explorer on the
left-hand side of the Java perspective. If you expand the project hierarchy,
you should see something like Figure 2.8.
Figure 2.8: HelloWorld Project
Title Structure
The src directory in Figure 2.8 contains the source that was
generated by the application template. The main title source is found in the
helloworld.title, helloworld.actors, and helloworld.roles
packages. The gen directory, located under src, is where the
mastered elements exist. The mastered elements were generated from the Digital
Workprint located in the workprints directory. The Digital
Workprint for this example is called HelloWorld.dwp.
For more information concerning the HelloWorld title components, please read the section
on "HelloWorld Title Application".
Executing the Title
To execute the title, you will need to create a launch configuration. You will
also need to pass the Digital Playprint, HelloWorld.dpp, as
a command-line argument to the application's main entry point (main()
method in helloworld.title.HelloWorld class).
If you are anxious to see this title run, then generate a default launch configuration by
selecting the HelloWorld.java file in the Package Explorer view.
Right-click on the file and select "Run As->Magic Lantern Title". The title will show the
"Hello World!" text string in a window titled "MLE 2D Stage".
For more information about title execution, please proceed to
"Executing the Title".


Friendzone was built with gamers in mind. With this social medial style
application, we allow gamers to create a profile with their
"gamer-tags" from any platform, search/follow all of the games they play, and follow
their friends.
Once a user follows a specific game, they can enter a game specific chat to meet up
with other people. After game play, users are able to up/down vote other gamers, and
"gamer rep" will be reflected publicly. Built with a Node.js backend, mongoDB
database, Auth0 for user management and a Vue.js frontend.
With Kanban, a peer and I build a visually pleasing task manager
application. A user is able to create a task board and can then create tasks
specific to that board and lists specific to those tasks. From there users can
create comments on those tasks. Boards can be user specific by logging in with
Auth0. Built with a Node.js backend, mongoDB database, Auth0 for user management and
a Vue.js frontend.
Keepr is a full stack social media application that allows users to
visually share and discover new interests by posting images or videos to their own
collection. Users that
are not logged in can see all public posts and can open them for more details. Built
with
a
.Net WebApi implementing the repository pattern to communicate with a MySQL
database, Auth0 for user management, and a
Vue.js frontend.


The row in the header shows your web3 wallet status:
- web3 connection status
- balance of your connected wallet
- address of your connected wallet
- address of VerifiedProxy smart-contract, used for transfers of ether
- network (we have now only launched on Ropsten test network. Your wallet should be switched to Ropsten to work)
The connected web3 wallet is required to use current prototype. We recommend using MetaMask. If you’re using MetaMask - open your wallet extension in browser, in the upper left corner click current network (usually it shows you’re on Mainnet) and select Ropsten in the dropdown. That’s it.
You should select «Send» tab, type in the phone of the person you’re sending ether to, and the amount. The commission is added to the amount that you intend to pay, and the final amount to be charged from your account is written in the «amount to pay» tab. Please mind that you need to have this amount on your account to proceed.
When you press send, your MetaMask pop-up opens, verify transaction by pressing «submit», then you will see waiter rotating and that shows that your transaction is being processed. When it is sent, you will see the verification code. Please copy it to share with receiver, that is important, otherwise he wouldn’t be able to receive his assets.
You can press «show code» button to show the code again. However, if you’ve reloaded the page, the code’d be lost. But don’t worry and check the next question.
Don’t worry, all transfers via our smart-contract can be cancelled until receiver has withdrawn the transfer, and as you haven’t shared the code with anyone, no one will be able to do that. So, go to the history table list on the bottom of the page, select «awaiting receiving» tab and find your transaction there. Press «сancel» button. After you press it, your MetaMask pop-up opens, verify transaction by pressing «submit», then you will see waiter rotating and that shows that your transaction is being processed.You will see «cancelled» when the request will be processed. Do not reload your page during that action.
The table list on the bottom of the page has 3 tabs, according to the status of transaction.
- all «awaiting receiving» transactions in our system can be cancelled until receiver has verified the transaction
- «completed» - transaction has been successfully received
- «cancelled» - transaction has been cancelled
First two options are for users who have already dealed with ethereum and have a wallet.
- MetaMask is to receive to your connected web3 wallet ( the status of wallet is shown in the header - check the general section of FAQ)
- Type address - is to paste in your wallet address to receive funds to it
The third option is to generate a wallet on-the-fly in case you never had one.
Choose «Generate Wallet tab», enter and remember the password (you will need it to access your funds), press «Generate»
You will now see you wallet address and keystore data.
Wallet address can be shared with people to receive assets. Password and your keystore data should be stored securely and not shared with untrusted third parties.
1. Save your password and wallet address.
2. Save your keystore as text or as file (press «download keystore data» button)
1. After you’ve chosen the right method and done appropriate actions (connected your MetaMask or typed in the address or generated new wallet), press «continue» button.
2. You will then see and need to fill two inputs:
- your phone number - you should enter your phone here
- verification code - the sender should have shared this code with you, and it’s just about time to use it and enter it here. If he hadn’t - request it from him. If he’d lost it - see the appropriate question in «Sending» section of current FAQ.
After you fill in the inputs, you need to press «Send». You will receive an SMS with code and switch to next screen where you need to input that code from SMS. Sometimes receiving SMS can more than couple of seconds, please be patient.
3. When you get an SMS - fill the code from it to the input and press «Send». Your transaction will then bi finalized and you will see a transaction ID, you can copy it and check on the https://etherscan.io/


available here: http://dgschwend.github.io/netscope
This is a CNN Analyzer tool, based on Netscope by ethereon.
Netscope is a web-based tool for visualizing neural network topologies. It currently supports UC Berkeley’s Caffe framework.
This fork adds analysis capabilities, enabling the computation of network complexity (number of operations) and network size (number of parameters) for easy comparison of different networks.
Released under the MIT license.
All included network models provided under their respective licenses.


{%- extends "base.html" %} {%- import "macros.jinja2" as macros %} {%- block title %}{{ title }}{% endblock %} {%- block page_title %}{{ title }}{% endblock %} {%- block breadcrumbs %}
| title | show | episode | BGs | finished | approved | |
|---|---|---|---|---|---|---|
| {{ episode.title }} | {{ episode.show.title }} season {{ episode.show.season }} | {{ episode.format_padded_number() }} | {{ episode.bg_count }} | {{ macros.progress_bar(format_percent(episode.bg_count, episode.finished_bgs), css_pct(episode.bg_count, episode.finished_bgs)) }} | {{ macros.progress_bar(format_percent(episode.bg_count, episode.approved_bgs), css_pct(episode.bg_count, episode.approved_bgs)) }} | |
| No matching records were found. |


|
|
Sample Name is Required.
|
Garment Item is Required.
|
Body Part is Required.
|
Fabric Nature is Required.
|
Fabric Description is Required.
|
GSM is Required.
|
Dia is Required.
|
Color is Required.
|
Color Type is Required.
|
width/Dia is Required.
|
Uom is Required.
|
Finish Req. Qty. is Required.
|
Process Loss is Required.
|
Grey Req. Qty. is Required.
|
Fabric Del. Date is Required.
|
Fabric Source is Required.
|
|
|


Car Sharing Conflict
This week I will practice discussing a past conflict I had and examining my emotions, approach and identifying what I could have done differently. This will be a good exercise for reflecting on future conflicts and trying to understand it from the big picture and the perspective of the situation's affects on the people and situation around me.
Discuss a time you had a conflict. What was it about? What happened?
I wanted to use a recent example, since I think I've grown a lot in the past few years in how I try to approach conflicts. A recent conflict involved a person who rented my car through a car sharing service. They returned it to me while I was at work, so I didn't get a chance to look at the car later in the day. When I looked, there was damage to the rear bumper and it could only be fixed by being completely replaced. I contacted the car sharing service and they gave me only two options: deal directly with the renter to cover the cost, or go through the service and they would contact the renter. The problem with the second choice was that the renter would have to pay for the entire damage and also additional fees for me having the service take care of it.
What was the source of the conflict?
The source of the conflict is hard to pinpoint. The renter didn't realize that the bumper was damaged, which made me think it happened while it was parked on the street, or they were lying. Since I gave them the benefit of the doubt, I assumed it was an accident that could have happened to anyone. However, in the eyes of the car sharing service, since the car was under the renter's responsibility, even no-fault accidents were not covered by the insurance without the renter paying for it.
What basic emotions did you feel upon analyzing the conflict?
At first I felt angry at the renter because I initially suspected that they were lying to me. However, after thinking the situation over and over again, I decided it would be best to believe that it really was an accident and that the renter did not realize the accident happened. This made me a lot calmer and it made it easier to talk to the renter and ask them how we could deal with this. Additionally, I felt frustrated with the car sharing service because they did not cover accidents that were no fault of the renter, so I had to choose whether to pay for it myself, ask the renter to pay for it, or have the car sharing service force the renter to pay for it. This was also a moral dilemma for me because it was over a very expensive fix and I didn't want to impose that on someone just because it could have happened to anyone.
What actions did you take to resolve your conflict?
I decided to talk to the renter directly and let them know that I understood it was an accident and that it may not have been their fault. I asked them if they could offer any contribution to help get the bumper fixed and I phrased it so that they would have an easy out if they could not contribute anything. I was relieved when they offered to cover half of the cost to fix the bumper. I felt that going to them directly and being honest and open with them led to this compromise.
If you could go back, what would you do differently, if anything?
I'm not sure I would do anything differently, because I felt like it was a pretty good example of a compromise. I look back at this example as a time when I approached a situation only after I'd examined my initial emotions, so I wouldn't have to burden the person with negative feelings when they may not even realize they did something to upset me.
What did you learn from this experience?
From this and similar experiences I've learned that the best way to resolve a conflict is to talk about it openly, and also to talk about it when you're not feeling upset or angry. It's important to respect another person's emotional space, and approaching someone you are feeling angry will likely make the other person angry as well. Two angry people are never a productive force, and any chance of resolving the conflict is probably lost at that point. It usually works well when both parties are understanding and respectful of the other's intention and feelings.


Derrius Guice officially activated off injured reserve by Redskins
by Matthew ParasThe Washington Redskins announced Thursday they have activated running back Derrius Guice from injured reserve, paving the way for him to return next week against the New York Jets.
The 22-year-old has not played since Week 1 against the Philadelphia Eagles, when he tore his meniscus. The injury required a minor operation and put the running back on IR, requiring him to miss a minimum of eight weeks.
Guice won the starting running back job in training camp and the Redskins were prepared to have him be the “focal point” of their offense under coach Jay Gruden. But it is unclear how heavily the Redskins plan to use Guice now that Gruden is gone and veteran Adrian Peterson has reemerged as the team’s primary workhorse.
Interim coach Bill Callahan deflected a question last week when asked how he plans to divide reps between Peterson and Guice.
“That’s a question for two weeks from now,” Callahan said. “So, we’ll address that when the time is appropriate, when the game plan is put in and who we’re playing, how we’re going to attack that particular defense and how we’re going to divide the repetitions and rotations and things of that nature. Way too early to decide on reps and counts they’ll have for that particular game.”
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC. Click here for reprint permission.
Please read our comment policy before commenting.


Some projects only use a portion of the workspace and, in such cases, it is not necessary to check out the entire workspace. For example, when accessing a large remote repository to build a sub-module.
If you specify a sub-path, the plugin makes a "best effort" to ensure that only the sub-path is populated. This means that the files within the sub-path will be fetched, at least, but side-effects may result in files from other paths being fetched as well.
Note that the changelog does not filter by sub-path. Thus, any change in the repository will trigger a build.
When using a workspace, you must update the workspace which populates any changed files and not just the files in the sub-path. The subsequent populate ensures that all the files in the sub-path are fetched, at least.


This project is in progress as a part of my graduate thesis. This project is in process and I will be happy to discuss it in person.
Prolonged sitting due to computer work is a major contributor to a sedentary lifestyle. This increases longtime health risks and also causes repetitive strain injury in many people resulting in chronic pain in their wrist, arms, shoulders or back that limits their normal activity. There is strong evidence that taking micro-breaks every hour; as short a minute can substantially help the body to recover from the damage caused by inactivity. However, these breaks are often untimely, not context-aware, and disruptive to workflow.
Calm technologies like shape-changing devices have been a growing area of research in the field of Human-Computer Interaction. This project focusses ongoing in the context where RSI occurs, understanding the lived experience of these people, and including their voices early on in the design process. This was done by conducting an interactive session with 11 people who have Repetitive Strain Injury.
The session was designed to equip them to think about shape-changing devices. The participants started from a descriptive interview where they talked about their challenges, pain points, and coping strategy, moving to a critique of design provocations (low-fidelity physical prototypes) and finally to an imaginative design session where they expressed their desires and unspoken needs by making something using basic craft materials.


Previous
Next
One
Two
Three
Four
Five
Six
Seven
Eight
Nine
Ten
Eleven
Twelve
Thirteen
Fourteen
Fifteen
Sixteen


Imran Alam<EMAIL_ADDRESS>Daniel Krieglstein
Thursday 7:45pm to 8:45pm, Online
This course will cover the creation of Web pages and sites using HTML, CSS, Javascript and graphical applications.
Networked multimedia distribution technologies are also explored. The design of effective Web site including page layout,
user interface design, graphic design,
content flow and site structure as well as management of Web site resources
including intranet management and design considerations are addressed.
Students design and create a major Web site with multiple pages and cross-linked structures. Prerequisites: [none]Credit: 2-2-3 Semester Hours
Students completing this course will be able to:
At the conclusion of this course, each successful student will able to:


HTML and XHTML example files
These are small examples of various aspects of HTML.
Examples of documents
- bare.html
- Absolutely minimal HTML document.
- bare.xhtml
- Absolutely minimal XHTML document.
- standard.html
- HTML document with the recommended minimum structure.
- standard.xhtml
- XHTML document with the recommended minimum structure.
- standardx.html
- XHTML document to be served as text/html with the recommended minimum
structure.
Tests of HTML features
- ConditionalComment.html
- Testing Microsoft Conditional Comments
- empty_strict.html
- Empty XHTML element in HTML 4.01 strict. The document does not
validate but it does render okay in most browsers.
- empty_transitional.html
- Empty XHTML element in HTML 4.01 transitional. The document does
validate and renders okay in most browsers. An SGML compliant UA should
render an extra >.
- twometa_transitional.html
- Test of two meta elements with transitional doctype.
Pete Forman
Mail
Web
Last modified: 2008-02-29T11:16:55+00:00


The user profile that will be used to run the test.
Must be specified in the down-level logon name format, for example, DOMAIN\UserName.


Are you planning to do X feature?
See
our roadmap for our current todolist. Feel free to
tell us about your ideas! The current version of Trustroots is the most limited software you can imagine that still works for hospitality. We simply haven't had time to build most of the features yet. Please be patient and be mindful about
feature creep.
Could you offer mobile app at F-Droid store?
We would love to! However, it seems we cannot because of how our mobile app is built.
We don't have resources yet to build a separate "native app" for Android so we're using
Expo.io framework instead.
Using Expo
seems to block inclusion to F-Droid, although we don't directly use any of the services mentioned in the blocking list but Expo itself might. Expo is an
open source project.
However, you can simply download our apk file manually:
apk.trustroots.org — this version might not support all the features though, such as push notifications.
If you would like to help solve this,
get in touch!


| Opcode/Instruction | Op /En | 64/32 bit Mode Support | CPUID Feature Flag | Description |
|---|---|---|---|---|
|
66 0F 38 2A /r MOVNTDQA xmm1, m128 |
RM | V/V | SSE4_1 | Move double quadword from m128 to xmm1 using non-temporal hint if WC memory type. |
|
VEX.128.66.0F38.WIG 2A /r VMOVNTDQA xmm1, m128 |
RM | V/V | AVX | Move double quadword from m128 to xmm using non-temporal hint if WC memory type. |
|
VEX.256.66.0F38.WIG 2A /r VMOVNTDQA ymm1, m256 |
RM | V/V | AVX2 | Move 256-bit data from m256 to ymm using non-temporal hint if WC memory type. |
|
EVEX.128.66.0F38.W0 2A /r VMOVNTDQA xmm1, m128 |
FVM | V/V |
AVX512VL AVX512F |
Move 128-bit data from m128 to xmm using non-temporal hint if WC memory type. |
|
EVEX.256.66.0F38.W0 2A /r VMOVNTDQA ymm1, m256 |
FVM | V/V |
AVX512VL AVX512F |
Move 256-bit data from m256 to ymm using non-temporal hint if WC memory type. |
|
EVEX.512.66.0F38.W0 2A /r VMOVNTDQA zmm1, m512 |
FVM | V/V | AVX512F | Move 512-bit data from m512 to zmm using non-temporal hint if WC memory type. |
| Op/En | Operand 1 | Operand 2 | Operand 3 | Operand 4 |
| RM | ModRM:reg (w) | ModRM:r/m (r) | NA | NA |
| FVM | ModRM:reg (w) | ModRM:r/m (r) | NA | NA |
Description
MOVNTDQA loads a double quadword from the source operand (second operand) to the destination operand (first operand) using a non-temporal hint if the memory source is WC (write combining) memory type. For WC memory type, the nontemporal hint may be implemented by loading a temporary internal buffer with the equivalent of an aligned cache line without filling this data to the cache. Any memory-type aliased lines in the cache will be snooped and flushed. Subsequent MOVNTDQA reads to unread portions of the WC cache line will receive data from the temporary internal buffer if data is available. The temporary internal buffer may be flushed by the processor at any time for any reason, for example:
a mis-speculation condition, and various fault conditions
The non-temporal hint is implemented by using a write combining (WC) memory type protocol when reading the data from memory. Using this protocol, the processor
does not read the data into the cache hierarchy, nor does it fetch the corresponding cache line from memory into the cache hierarchy. The memory type of the region being read can override the non-temporal hint, if the memory address specified for the non-temporal read is not a WC memory region. Information on non-temporal reads and writes can be found in “Caching of Temporal vs. Non-Temporal Data” in Chapter 10 in the Intel® 64 and IA-32 Architecture Software Developer’s Manual, Volume 3A.
Because the WC protocol uses a weakly-ordered memory consistency model, a fencing operation implemented with a MFENCE instruction should be used in conjunction with MOVNTDQA instructions if multiple processors might use different memory types for the referenced memory locations or to synchronize reads of a processor with writes by other agents in the system. A processor’s implementation of the streaming load hint does not override the effective
1.
ModRM.MOD = 011B required
memory type, but the implementation of the hint is processor dependent. For example, a processor implementa-tion may choose to ignore the hint and process the instruction as a normal MOVDQA for any memory type. Alter-natively, another implementation may optimize cache reads generated by MOVNTDQA on WB memory type to reduce cache evictions.
The 128-bit (V)MOVNTDQA addresses must be 16-byte aligned or the instruction will cause a #GP.
The 256-bit VMOVNTDQA addresses must be 32-byte aligned or the instruction will cause a #GP.
The 512-bit VMOVNTDQA addresses must be 64-byte aligned or the instruction will cause a #GP.
Operation
MOVNTDQA (128bit- Legacy SSE form)
DEST (cid:197)SRC
DEST[MAX_VL-1:128] (Unmodified)
VMOVNTDQA (VEX.128 and EVEX.128 encoded form)
DEST (cid:197) SRC
DEST[MAX_VL-1:128] (cid:197) 0
VMOVNTDQA (VEX.256 and EVEX.256 encoded forms)
DEST[255:0] (cid:197) SRC[255:0]
DEST[MAX_VL-1:256] (cid:197) 0
VMOVNTDQA (EVEX.512 encoded form)
DEST[511:0] (cid:197) SRC[511:0]
Intel C/C++ Compiler Intrinsic Equivalent
VMOVNTDQA __m512i _mm512_stream_load_si512(void * p);
MOVNTDQA __m128i _mm_stream_load_si128 (__m128i *p);
VMOVNTDQA __m256i _mm_stream_load_si256 (__m256i *p);
SIMD Floating-Point Exceptions
None
Other Exceptions
Non-EVEX-encoded instruction, see Exceptions Type1;
| EVEX-encoded instruction, see Exceptions Type E1NF. |
| If VEX.vvvv != 1111B or EVEX.vvvv != 1111B. |


Overview
Package
Class
Tree
Deprecated
Index
Help
PREV NEXT
FRAMES
NO FRAMES
All Classes
Packages
com.xith3d.collider
NOTE: There are currently no developers maintaining or supporting this package.
com.xith3d.collider.forces
com.xith3d.common
com.xith3d.datatypes
com.xith3d.gui
com.xith3d.image
com.xith3d.imaging
com.xith3d.io
com.xith3d.loaders
com.xith3d.loaders.ase
com.xith3d.loaders.texture
com.xith3d.occluder
com.xith3d.picking
com.xith3d.render
com.xith3d.render.jogl
com.xith3d.render.lwjgl
com.xith3d.render.lwjgl.test
com.xith3d.scenegraph
com.xith3d.scenegraph.behavior
com.xith3d.scenegraph.utility
com.xith3d.scenegraph.utility.general
com.xith3d.sound
com.xith3d.sound.drivers.javasound
com.xith3d.sound.drivers.joal
com.xith3d.sound.loaders
com.xith3d.spatial
com.xith3d.spatial.bounds
com.xith3d.spatial.clipping
com.xith3d.spatial.octree
com.xith3d.spatial.octree.triangle
com.xith3d.spatial.spheretree
com.xith3d.test
com.xith3d.test.lesson37vs
com.xith3d.test.tcm
com.xith3d.transients
com.xith3d.utilities
com.xith3d.utility.cache
com.xith3d.utility.cmdline
com.xith3d.utility.events
com.xith3d.utility.exception
com.xith3d.utility.general
com.xith3d.utility.geometry
com.xith3d.utility.geometry.nvtristrip
com.xith3d.utility.image
com.xith3d.utility.interpolate
com.xith3d.utility.logs
com.xith3d.utility.memory
com.xith3d.utility.noise
com.xith3d.utility.profile
com.xith3d.utility.properties
org.odejava
org.odejava.collision
org.odejava.display
Used to bind ODE to the display library of your choice.
org.odejava.ode
Low level 1:1 binding of the C ODE library.
org.odejava.test
org.odejava.test.car
org.odejava.test.simple
org.odejava.test.xode
org.odejava.xith3d
org.odejava.xith3d.test
org.odejava.xode
Overview
Package
Class
Tree
Deprecated
Index
Help
PREV NEXT
FRAMES
NO FRAMES
All Classes


Please correct the error below.
Delete
Required. 30 characters or fewer. Letters, digits and @/./+/-/_ only.
Raw passwords are not stored, so there is no way to see this user's password, but you can change the password using this form.
Designates whether this user should be treated as active. Unselect this instead of deleting accounts.
Designates whether the user can log into this admin site.
Designates that this user has all permissions without explicitly assigning them.
The groups this user belongs to. A user will get all permissions granted to each of his/her group. Hold down "Control", or "Command" on a Mac, to select more than one.
Specific permissions for this user. Hold down "Control", or "Command" on a Mac, to select more than one.
Date: Time:


PostgreSQL Integration
SQL Connection Init Implementation
The first thing that is needed is to setup the connection to your PostgreSQL server and your application. What you need to do is make a Java class that implements io.brosoft.dao.SqlDbInit
public class PostgresqlInit implements SqlDbInit {
@Override
public Connection initDatabase() {
Connection connection;
try {
String connectionUrl = "jdbc:postgresql://localhost:5432/test";
Class.forName("org.postgresql.Driver");
Properties props = new Properties();
props.setProperty("user","postgres");
props.setProperty("password", "");
connection = DriverManager.getConnection(connectionUrl,"postgres","postgres");
Statement statement = connection.createStatement();
String createTableSql = "CREATE TABLE IF NOT EXISTS sampleTable ("
+ "name TEXT PRIMARY KEY NOT NULL,"
+ "species TEXT NOT NULL,"
+ "occupation TEXT NOT NULL)";
statement.execute(createTableSql);
statement.close();
} catch (SQLException | ClassNotFoundException e) {
throw new RuntimeException(e);
}
return connection;
}
}
Marking your Java Beans for DAO Usage
Next you should annotate your Java beans to be used by the DAO. If you do not supply a key for the field it will default to the Java field name.
public class PostgresqlBean {
@SQLField
public String name;
@SQLField
public String species;
@SQLField
public String occupation;
}
Making a DAO Class
This is extremely simple as all you need to do is simply annoatate both the MongoInit implementation, as well as the Java Bean that it is using. The DAO's param type will be the Type of the Java Bean
@SQLTable(dbInitializer = PostgresqlInit.class, bean = PostgresqlBean.class, table = "sampleTable")
public class PostgresqlDaoExample extends SQLDao<PostgresqlBean> {
}
Using the DAO
Usage of the DAO is straight forward and simple. Instantiate using the deafult constructor and perform CRUD operations.
public class PostgresqlExample {
public static void main(String[] args) throws ExecutionException {
SQLDao<PostgresqlBean> dao = new PostgresqlDaoExample();
PostgresqlBean bean1 = new PostgresqlBean();
bean1.name = "Fox McCloud";
bean1.species = "Red Fox";
bean1.occupation = "Star Fox Team Leader";
PostgresqlBean bean2 = new PostgresqlBean();
bean2.name = "Falco Lombardi";
bean2.species = "Avian";
bean2.occupation = "Star Fox Team Ace Pilot";
System.out.println( "create " + dao.create(bean1));
System.out.println( "delete " + dao.delete(new KeyPair("name", bean1.name)));
System.out.println( "create " + dao.create(bean1));
System.out.println( "update " + dao.update(bean2, new KeyPair("name", bean1.name)));
for (PostgresqlBean bean : dao.readAll()) {
System.out.printf("name: %s, species: %s, occupation: %s\n", bean.name, bean.species, bean.occupation);
}
System.out.println( "delete " + dao.delete(new KeyPair("name", bean1.name)));
System.out.println( "delete " + dao.delete(new KeyPair("name", bean2.name)));
}
}


Angular Examples
Big Picture
NgModule
View Encapsulation
Component Composition
Forms
Template Driven
Model Driven
Custom Control
Lifecycle Hooks
Lifecycle Hooks Call Order
Server Communication
Routing
Simple Routing
Route Parameters
Nested Routes
Guards
Resolve
Async
Form Validation
Template Driven
Model Driven
Unit Tests
Directives
Attribute Directive
Structural Directive
Pipes
Built-in
Custom
Change Detection
OnPush
Visualization
Detach
RxJS
Basics (map, filter, reduce)
Counter
Autocomplete
Errors
Subject
Redux Demo
ngrx Demo


- Assay: {{test._assay.name}}
- Device: {{test._device.name}}
- Cartridge: {{test._cartridge.name}}
- Status: {{test.status}}
- Percent complete: {{test.percentComplete}}
- Test succeeded: {{!test._cartridge.failed | uppercase}}
- Result: {{test._cartridge.result}}
- Test started on: {{test._cartridge.startedOn | date: medium}}
- Test finished on: {{test._cartridge.finishedOn | date: medium}}
Posted on
by


WITNESS LIST Agriculture & Livestock Committee March 4, 1997-8:00A HB 950 For: Jones, Delwin (Representative)


UKCloud FAQs
This article provides a list of FAQs on UKCloud services, technology, connections and processes.
UKCloud for Microsoft Azure FAQs
UKCloud for OpenShift FAQs
UKCloud for OpenStack FAQs
UKCloud for Oracle Software FAQs
UKCloud for VMware FAQs
Cloud GPU FAQs
Cloud Storage FAQs
Cross Domain Security Zone FAQs
Disaster Recovery as a Service FAQs
Email and Collaboration FAQs
Managed Services FAQs
Private Cloud FAQs
Secure Remote Access FAQs
Connectivity FAQs
Other FAQs
Feedback
If you find a problem with this article, click Improve this Doc to make the change yourself or raise an issue in GitHub. If you have an idea for how we could improve any of our services, send an email to feedback@ukcloud.com.


|
SUBJECT INDEX Anthropology Architecture Art Black Studies Business Ecology Economics Education Film Healthcare History Law Linguistics Literature Mass Media Medicine Music Philosophy Political Science Psychology Religion Science Shakespeare Sociology Sports Recreation Urban Studies Women's Studies |
Law: RehabilitationTo order a specific paper, click the Catalog Number button next to the Paper Title of interest. Send comments to<EMAIL_ADDRESS>Last Updated: 12/21/96 Copyright ©1996 ASM Communications, Inc. All Rights Reserved. |


At the heart of the new frontier of Amsterdam’s vibrant business community, Out of the Office serves on honorable mission in relentlessly making sure that he hardest working men and women in town can enjoy a quick and rejuvenating refreshment when needed to.
Here, one can not only can you enjoy a dry grainy hummus turd sandwich, but aenjoy one of our cups from a great variety of godlike caffeinated brews for your pleasure, where household flagship cup Mocca-Chocho-Mint-Bullshit is our most famous and sought after overpriced steal of a hot mess.
Don’t you feel repealed or applaud by the idea of using us or our services for you personal gain and benefit as you power play you colleagues in the lunchroom by showing up witch fresh hommus turd sandwich cake for every one to enjoy.  Order our catering services today, and win them all. You can et in touch with us here.
 I drink it, I eat it, I breathe it. I sleep with it. I travel the world to gather the best beans to bre right here in your lobby every morning. If you can't get enough of me, follow me on twitter for a live stream of my process of burning the beans.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam viverra euismod odio, gravida pellentesque urna varius vitae.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam viverra euismod odio, gravida pellentesque urna varius vitae.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam viverra euismod odio, gravida pellentesque urna varius vitae.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam viverra euismod odio, gravida pellentesque urna varius vitae.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam viverra euismod odio, gravida pellentesque urna varius vitae.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam viverra euismod odio, gravida pellentesque urna varius vitae.
You can find us at John M. Keynesplein 4-10, in the lobby to the office building.
address


Fortnite dungeons are here, and I can't resist the hype anymore
I've resisted the call of Fortnite thus far, but I can't anymore.
by Dan Thorp-LancasterSource: Epic Games
I've managed to keep the call of Fortnite at bay so far, but I don't think that's possible anymore. Battle royale, the game's most popular mode, never really appealed to me (likely because I'm terrible at PvP shooters). But now that dungeons are here, I'm very close to being sucked in by the hype.
The dungeons are available now in Fortnite's PvE Save the World mode. This is the mode that originally appealed to me way back when Epic Games first teased Fortnite, but it was quickly overshadowed by the free-to-play Battle Royale mode. I'm not sure why I never gave Save the World a shot before now, but it probably comes down to a cynical urge to not give in to the game's surging popularity.
All of that is out the window now. If there's anything I like in a game, it's dungeon crawling. Sure, there are better dungeon crawlers out there, but there's something about the mix of Fortnite's goofy premise and colorful aesthetic that makes me want to dive in with some friends and smash my way to glorious loot.
I've had my fill of hardcore dungeon crawling as a raider in World of Warcraft back in the day, and I'm holding off on jumping back into Diablo until Diablo IV hits the scene (it looks phenomenal, by the way). Right now, I'm totally into taking on something a lot more lighthearted where I don't have can simply shoot, smash, and loot.
So, for now, you'll find me joyously cruising through Fortnite's four dungeons. Will it be enough to hold me over for now? Who knows. Hopefully Epic Games already has some follow-up dungeons in the pipeline.
If anything, it'll help me avoid emptying my wallet on the coming deluge of Black Friday deals as I tune out the rest of the world and take down some husks. The only thing that'll suffer is my gaming backlog, but I'm okay with that for now.

- Best Xbox One X and Xbox One S Accessories
- Best Xbox One Headsets 2019
- Best Xbox One Wireless Headsets 2019
- Best Xbox Controller Charging Stations in 2019
We may earn a commission for purchases using our links. Learn more.


Introduction
In this section we will be writing shellcode for the ARM platform. We will try to mirror the shellcoding for x86 section as closely as possible. In other words, every time we make an accomplishment for the x86 platform, we will strive to repeat that accomplishment for the ARM platform.
The shellcode we will be writing here will set the setruid to that of root and spawn a shell with root level privileges.
Project code is contained in my github.
The program shellcode.s
The screenshot below displays the contents of the program shellcode.s. We need to assemble, link, run and instruction step this program in GDB.
Since our computer is an AMD64 platform, we will execute the assembly code on a Raspberry Pi 2, which is an ARM platform. We will connect to a running RPi2 via the VNC viewer.
The program is assembled with:
$ as -ggdb3 shellcode.s -o shellcode.o
We then obtain the object file and look at it's objdump. The results of these operations is shown below:
Linking and Running shellcode.s to Obtain Root Shell
Running shellcode.s in GDB + GEF
Running step 1
Running shellcode.s in GDB + GEF
Running step 2
Running shellcode.s in GDB + GEF
Running step 3
Running shellcode.s in GDB + GEF
Running step 4
Running shellcode.s in GDB + GEF
Running step 5


Intro to Ruby & Web Dev: Inheritance
12 Sep 2014Inheritance
Subclasses inherit attributes and behaviors of superclasses.
When in cases of subclasses and superclass with the same class methods, the subclass will overide the superclass because ruby checks an object class before moving to the superclass. n the GoodDog class, we're overriding the speak method in the Animal class because Ruby checks the object's class first for the method before it looks in the superclass. So, that means when we wrote the code sparky.speak, it first looked at sparky's class, which is GoodDog. It found the speak method there and used it.
DRY
Inheritance can be a great way to remove duplication in your code base. There is an acronym that you'll see often in the Ruby community, "DRY". This stands for "Don't Repeat Yourself". It means that if you find yourself writing the same logic over and over again in your programs, there are ways to extract that logic to one place for reuse.
Mixing in Modules
Another way to DRY up your code in Ruby is to use modules. We've already seen a little bit of how to use modules, but we'll give a few more examples here.
Extracting common methods to a superclass, like we did in the previous lesson, is a great way to model concepts that are naturally hierarchical.
Inheritance vs Modules
Now that you know the two primary ways that Ruby implements inheritance, class inheritance and mixing in modules, you may wonder when to use one vs the other. Here are a couple of things to remember when evaluating those two choices.
You can only subclass from one class. But you can mix in as many modules as you'd like. If it's an "is-a" relationship, choose class inheritance. If it's a "has-a relationship, choose modules.  You cannot instantiate modules (i.e., no object can be created from a module) Modules are used only for namespacing and grouping common methods together.
Method Lookup Path
Now that you have a grasp on both inheritance and mixins. Let's put them both together to see how that affects the method lookup path. Recall the method lookup path is the order in which classes are inspected when you call a method.
There are several interesting things about the above output. First, this tells us that the order in which we include modules is important. Ruby actually looks at the last module we included first. This means that in the rare ocurrance that the modules we mix in contain a method with the same name, the last module included will be consulted first. The second interesting thing is that the module included in the superclass made it on to the method lookup path. That means that all GoodDog objects will have access to not only Animal methods, but also methods defined in the Walkable module, as well as all other modules mixed in to any of its superclasses.
Private, Public, and Protected Methods
Public Methods are available to all Non-callable inside or outside a class but can be interpolated Protected methods act as public methods inside the class, therefore can be called but act as private methods outside of the class.
private
def human_years
self.age / DOG_YEARS
end
sparky = GoodDog.new("Sparky", 4)
sparky.human_years
We get the error message:
NoMethodError: private method `human_years' called for
#<GoodDog:0x007f8f431441f8 @name="Sparky", @age=28>
We have made the human_years method private by placing it under the private reserved word. So what is it good for if we can't call it? private methods are only accessible from other methods in the class. For example, given the above code, the following would be allowed:
Assume the method definition below is above the "private" keyword
def public_disclosure
"#{self.name} in human years is #{human_years}"
end
Note that in this case, we can not use self.humanyears, because the humanyears method is private. Remember that self.humanyears is equivalent to sparky.humanyears, which is not allowed for private methods. Therefore, we have to just use human_years. In summary, private methods are not accessible outside of the class definition at all, and are only accessible from inside the class when called without self.


Bruce Wayne
Home
Profile
Logout
Home
eric
Clark Kent
ckent
<EMAIL_ADDRESS>Joined on
Oct 19, 2012
Organizations
Applications
Services
Activity
New Org
JBoss Overlord
12
52
32
Overlord is the umbrella project that will bring governance to the JBoss SOA Platform and eventually beyond.
Apereo Bedework
5
159
3
Bedework is an open-source enterprise calendar system that supports public, personal, and group calendaring.


PERLBEOS
Section: Perl Programmers Reference Guide (1)Updated: 2009-02-12
Index Return to Main Contents
NAME
README.beos - Perl version 5.8+ on BeOSDESCRIPTION
This file contains instructions how to build Perl under BeOS and lists known problems.BUILD AND INSTALL
Requirements
I have built and tested Perl 5.8.6 and 5.9.1 under BeOS R5 x86 net server. I can't say anything with regard to PPC. Since Perl 5.8.0 had been released for BeOS BONE, I suspect, there is a good chance, that it still compiles on a BONE system. The only change I've made, that affects BONE systems is the recognition of whether it is a BONE system or not in "hints/beos.sh". Now network socket support should remain enabled on BONE systems. This might as well break the build, though.As more recent versions of autoconf require flock() support, I wrote a flock() emulation (flock_server) and released it on BeBits:
http://www.bebits.com/app/4030
If you want to build a Perl with flock() support, you have to install this package first.
Configure
With flock() support:
CFLAGS=-I/path/to/flock/server/headers ./configure.gnu \ --prefix=/boot/home/config
Replace "/path/to/flock/server/headers" with the path to the directory containing the "flock.h" header.
Without flock() support:
./configure.gnu --prefix=/boot/home/config
Build
With flock() support:
make LDLOADLIBS="-lnet -lflock"
Without flock() support:
make LDLOADLIBS="-lnet"
"-lnet" is needed on net server systems only and if the compiler doesn't add it automatically (Be's R5 gcc does, Oliver Tappe's gcc 2.95.3 does not).
Install
Install all perl files:
make install
Create a symlink for libperl:
cd ~/config/lib; ln -s perl5/5.8.6/BePC-beos/CORE/libperl.so .
Replace 5.8.6 with your respective version of Perl.
KNOWN PROBLEMS
- *
- Network socket support is disabled for BeOS R5 net server. I didn't dare yet to try enabling it and see what problems occur.
- *
- The LFS (large file support) tests ("t/op/lfs" and "xt/Fcntl/t/syslfs") are disabled as seeking beyond 2 GB is broken according to<EMAIL_ADDRESS>who was the last one checking the BeOS port and updating this file before me. Haven't checked this myself.
- *
- The "t/io/fflush" test fails at #6. As far as I can tell, this is caused by a bug in the BeOS pipes implementation that occurs when starting other child processes. In the particular test case a "system("perl -e 0")" flushes the stdout pipe of another child process.
- *
- The "ext/POSIX/t/waitpid" test fails at #1. After all child processes are gone BeOS' waitpid(-1,...) returns 0 instead of -1 (as it should). No idea how to fix this.
CONTACT
For BeOS specifics problems feel free to mail to: Ingo Weinhold<EMAIL_ADDRESS>update: 2004-12-16
Index
This document was created by man2html, using the manual pages.
Time: 05:29:07 GMT, December 24, 2015


Guitar scale builder
This tool allows you to build your own guitar scale.
Click on the notes to change the current scale. Active notes have a light green background.
c
c#
d
d#
e
f
f#
g
g#
a
a#
b


Blocking Slave Example
Blocking Slave shows how to create an application for a serial interface using QSerialPort's synchronous API in a non-GUI thread.
QSerialPort supports two general programming approaches:
- The asynchronous (non-blocking) approach. Operations are scheduled and performed when the control returns to Qt's event loop. QSerialPort emits a signal when the operation is finished. For example, QSerialPort::write() returns immediately. When the data is sent to the serial port, QSerialPort emits bytesWritten().
- The synchronous (blocking) approach. In non-GUI and multithreaded applications, the
waitFor...()
functions can be called (i.e. QSerialPort::waitForReadyRead()) to suspend the calling thread until the operation has completed.
In this example, the synchronous approach is demonstrated. The Terminal example illustrates the asynchronous approach.
The purpose of this example is to demonstrate a pattern that you can use to simplify your serial programming code, without losing responsiveness in your user interface. Use of Qt's blocking serial programming API often leads to simpler code, but because of its blocking behavior, it should only be used in non-GUI threads to prevent the user interface from freezing. But contrary to what many think, using threads with QThread does not necessarily add unmanageable complexity to your application.
This application is a Slave, that demonstrate the work paired with Master application Blocking Master Example.
The Slave application is receives the request via serial port from the Master application and send a response to it.
We will start with the SlaveThread class, which handles the serial programming code.
class SlaveThread : public QThread { Q_OBJECT public: explicit SlaveThread(QObject *parent = nullptr); ~SlaveThread(); void startSlave(const QString &portName, int waitTimeout, const QString &response); void run() Q_DECL_OVERRIDE; signals: void request(const QString &s); void error(const QString &s); void timeout(const QString &s); private: QString portName; QString response; int waitTimeout; QMutex mutex; bool quit; };
SlaveThread is a QThread subclass that provides an API for receive requests from Master, and it has signals for delivering responses and reporting errors.
You should be call startSlave() to startup Slave application. This method transfers to the SlaveThread desired parameters for configure and startup the serial interface. When SlaveThread received from Master any request then emitted the request() signal. If any error occurs, the error() or timeout() signals is emitted.
It's important to notice that startSlave() is called from the main, GUI thread, but the response data and other parameters will be accessed from SlaveThread's thread. SlaveThread's data members are read and written from different threads concurrently, so it is advisable to use QMutex to synchronize access.
void SlaveThread::startSlave(const QString &portName, int waitTimeout, const QString &response) { QMutexLocker locker(&mutex); this->portName = portName; this->waitTimeout = waitTimeout; this->response = response; if (!isRunning()) start(); }
The startSlave() function stores the serial port name, timeout and response data, and QMutexLocker locks the mutex to protect these data. We then start the thread, unless it is already running. QWaitCondition::wakeOne() will be discussed later.
void SlaveThread::run() { bool currentPortNameChanged = false; mutex.lock(); QString currentPortName; if (currentPortName != portName) { currentPortName = portName; currentPortNameChanged = true; } int currentWaitTimeout = waitTimeout; QString currentRespone = response; mutex.unlock();
In the run() function, start by acquiring the mutex lock, fetch the serial port name, timeout and response data from the member data, and then release the lock again. Under no circumstance should the method startSlave()
be called simultaneously with a process fetching these data. QString is reentrant but not thread-safe, and it is not recommended to read the serial port name from one startup, call and timeout or response data of another. SlaveThread can only handle one startup at a time.
The QSerialPort object we construct on stack into run() function before loop enter:
QSerialPort serial; while (!quit) {
This allows us once to create an object, while running loop, and also means that all the methods of the object will be executed in the context of the run() thread.
In the loop, check whether the name of the serial port for the current startup has changed or not. If it has, re-open and reconfigure the serial port.
if (currentPortNameChanged) { serial.close(); serial.setPortName(currentPortName); if (!serial.open(QIODevice::ReadWrite)) { emit error(tr("Can't open %1, error code %2") .arg(portName).arg(serial.error())); return; } } if (serial.waitForReadyRead(currentWaitTimeout)) {
The loop will continue waiting for request data:
// read request QByteArray requestData = serial.readAll(); while (serial.waitForReadyRead(10)) requestData += serial.readAll();
Warning: The method waitForReadyRead() should be used before each read() call for the blocking approach, because it processes all the I/O routines instead of Qt event-loop.
The timeout() signal is emitted if error occurs when reading data.
} else { emit timeout(tr("Wait read request timeout %1") .arg(QTime::currentTime().toString())); }
After a successful read, try to send a response and wait for completion of the transfer:
// write response QByteArray responseData = currentRespone.toLocal8Bit(); serial.write(responseData); if (serial.waitForBytesWritten(waitTimeout)) { QString request(requestData); emit this->request(request);
Warning: The method waitForBytesWritten() should be used after each write() call for the blocking approach, because it processes all the I/O routines instead of Qt event-loop.
The timeout() signal is emitted if an error occurs when writing data.
} else { emit timeout(tr("Wait write response timeout %1") .arg(QTime::currentTime().toString())); }
After a successful writing is emitted, request() signal containing the data received from the Master application:
emit this->request(request);
Next, the thread switches to reading the current parameters for the serial interface, because they can already have been updated, and run the loop from the beginning.
mutex.lock(); if (currentPortName != portName) { currentPortName = portName; currentPortNameChanged = true; } else { currentPortNameChanged = false; } currentWaitTimeout = waitTimeout; currentRespone = response; mutex.unlock(); }
Running the Example
To run the example from Qt Creator, open the Welcome mode and select the example from Examples. For more information, visit Building and Running an Example.
Files:
See also Terminal Example and Blocking Master Example.