Previous URL : http://www.viewsunplugged.com/VU/20040922/books_excerpts_laPaz.shtml
Return to La Paz:
A chapter from Thomas Reissman's recently published novel 'Return to La Paz'.
Everyone around me was murmuring in prayer. I assumed it to be the Lord’s Prayer, but really I had no idea because they were speaking Portuguese. But even if they had been speaking German or English, I would not have known the words. Where I grew up I had always been told that religion is opiate for the people, thus I had not been given my doses like most other people. Did I believe in god, though? Well, I believed Allanis Morisette, who incidentally played god in the movie Dogma, when she sang that life is ironic. Because wasn’t it ironic that I was now here, in Northern Bolivia, with a group of Christians, about to take their own sacred opiate, which supposedly would open the door to the kingdom of god?
They stopped praying, passed Santa Maria, neatly packed into a joint, and began serving the reddish liquid from a corked wine bottle, in total silence. The surrounding jungle was anything but silent. Nevertheless, an array of noises poured into the open windows of the small wooden church, only slightly lit by several candles on the table in front of us.
“Like someone playing a synthesiser in the jungle,” Andreas the German, whom I had met just two weeks ago, had said. He was the one who had first told me about the Santo Daime.
“It is Jesus Christ liquefied,” he had said. I was about to find out what that meant. One by one the twelve women and men were given the sacrament. It was my turn now. This was my last chance to bail out. My heart was pounding as I traced the cross over my chest, holding a cup full of liquid, red Jesus.
‘This is the point of no return; there’s no going back after that,’ I thought and poured the sour-tasting liquid down my throat. I could almost hear the eerie metallic sound of my liquefied mirror image disappearing inside, just like in one of the scenes of The Matrix, as Neo was beginning to feel the effect of the red pill. The voice of Morpheus was ringing in my ear: “Have you ever had a dream that was so real, that you could not tell the difference to the real world? What if you were unable to wake from that dream?”
I walked back to the table and they began singing. Someone had lit a stick of Palo Santo, and the sweet-smelling scent gave the atmosphere an almost holy air. Once we were all served, we sat down again — woman on one side of the table and men on the other. Someone pointed to the book in front of me, indicating the verse they were about to sing.
“Dai-me forna e Dai-me amor para eu poder trabalhar.”
As I became engaged in the lyrics I somehow lost my grasp of time. The concept suddenly appeared strange, because it presupposed change, while I had the distinct feeling that nothing was actually changing. I looked at my body and to my surprise I could not fully identify with it; in fact, it felt rather alien. A thought entered my mind: ‘That’s not me, but then who or what am I?’ That was a bit of a nutcracker and required my fullest attention, I could not concentrate on the lyrics anymore and my head became heavy, so I just lay it down on the table in front of me, while my arms were dangling loosely. Thoughts were running ambush in my mind. What was I doing here with this crazy sect? What would my father say? ‘He completely lost it now,’ something along those lines probably. I remembered the words of my girlfriend: ‘I have learned so much from you already. You have given me so much optimism.’ That thought made me smile. Someone tapped me on my shoulder.
“You have to do some more work my friend,” the voice said to me in Spanish. At that very instant a fluorescent green grasshopper landed on the table right next to me, and someone started playing the flute. The sound of the flute wandered up my spine and I was suddenly filled with energy again. I managed to stand up, along with everyone else. I heard the American vomiting out the window and knew I was not alone in my weakness. I began formulating the words I read in the book I held in my hands, after my eyes had slowly adjusted to the letters. “Eu canto aqui na terra. Oh amor que Deus nos da.
Para sempre. Para Sempre
Ah minha ma que vem com migo
Para sempre. Para sempre.”
I closed my eyes and let the sound of sempre reverberate within me. It found its way into my head first and then began moving down my spine, somehow filling my body with the vibration of eternity and then I lost every last bit of sense. That reminded me of time, indeed of any familiar concept. Every sensation, touch, smell, balance, taste and vision melted into one: a bright white light of eternal bliss. An immense electric current of peace and joy overcame me and I knew without thinking that this is where we came from and where we will return to, eventually.
© Copyright 2001-2003 Thomas Reissman
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


I'm a creator at heart, I love to work on new ideas and bring them to life. I've worked as a radio broadcaster - hosting shows, producing content, as well as interviewing celebrities, influencers and local leaders on various topics. Today you find me working as a software developer. I work on my craft daily to become a proficient developer. How can I help you today? Reach out to me and let's talk.
• Developed frontend web applications using HTML/CSS and JavaScript.
• Used GitHub best practices to control the source of coding projects and managed versions of
software during development.
• Experience using Node.js, MySql, Bootstrap, and other frontend and backend technologies.
• Learned multiple languages and design programs centered around web development.
• Created website content, design, and updated web page content.
In the process of completing a 23-week professional training certification course focused on the skills needed to design
and build web applications. The program includes hundreds of hours of professional development and hands-on practice.
This program focuses on:
• Adobe Photoshop Creative Cloud
• Front-End Web Development Using Photoshop, HTML, CSS, Javascript, Bootstrap
• Back-end Development In PHP
• Capstone Project And Showcase
• Internship Designing For Local Business Partners


worklog
Created with
React + Electron
and
by
Yogiraj Pujari
(https://github.com/mags749)
(version 1.1.3)


I opened the Orange Door which held a BAD THING. Now if you want to switch you can choose the Green Door or you can keep your first choice and open the Blue Door.


Preparation time
over 2 hours
Cooking time
10 to 30 mins
Serves
Serves 2
Make sure the steak is dry before you begin. Using your hands, press the black and white peppercorns into both sides of the steak. If you have time, cover with foil/clingfilm and leave for the pepper flavour to infuse into the steak for 2-3 hours.
Pour the olive oil into a heavy-based frying pan and, over a high heat, seal the steak for two minutes on each side.
Reduce the heat, add half the butter to the pan and cook the steak for a further 5-10 minutes, turning one more time. You can reduce the cooking time if you like your steak quite rare. Once cooked to your liking, remove the steak from the pan and set aside to rest.
Pour away most of the fat remaining in the pan. Now add the remaining butter and the shallots. Over a medium heat, cook the shallots until soft, but not brown.
Pour in the Worcestershire sauce, brandy and stock. Cook rapidly, scraping the bottom of the pan to incorporate all the flavours.
Add the green peppercorns, mustard and cream. Season to taste.
To make the chips, peel the potatoes and cut them into chunky chips. Place in a bowl of water for a couple of minutes - this helps remove the starch. Pour the sunflower or vegetable oil into a deep-sided pan, making sure it is no more than a quarter full if you're using an open pan; no more than half full if using a deep-fat fryer. Heat to 160C/325F/Gas 2.
Drain the chips and dry them on kitchen paper before placing them in a wire basket and lowering them into the heated oil. Cook them in small batches so that they don't stick together. Cook for four minutes until cooked through but not coloured. Remove from the oil and drain.
Increase the temperature of the oil to 190C/375F/Gas 5. Tip the blanched chips back into the wire basket and then carefully lower into the heated oil. Cook for a minute or two until crisp and golden brown. Drain well on kitchen paper.
Slice the steak on the diagonal and add to the sauce. Stir to combine the meat juices with the pepper sauce, and to warm the meat through. Do not re-boil.
Serve with the chips.


Tasks
({{remaining.length}})
{{task.body}}
✗
✔
Add Task
Mark All as Completed
Completed({{completions.length}})
{{task.body}}
✗
Clear Completed
{{$data | json}}


Since September 2014, Mexican authorities require all vehicles traveling on federal roads, bridges and airports to hold a liability coverage policy issued by a Mexican insurance carrier.
U.S., Canadian, or any foreign insurance policy is not considered "proof of financial liability" under the Mexican law.
Additionally, some States in Mexico –such as Baja California, Jalisco, Sinaloa as well as Mexico City– require all vehicles to have at least a liability insurance policy.
In the event of an accident, some U.S. policies will cover damage on the insured vehicle (usually only within the first 25 miles South of the border), but NO FOREIGN COMPANY can legally cover third-party damages (liability).
Under Mexican law, most traffic accidents are considered a felony and authorities can retain both the driver and the vehicle until proof of liability is presented.
Tanto el vehículo como el conductor responsables pueden ser retenidos por las autoridades
hasta que se presente una prueba válida de responsabilidad civil.
• Dynamic Network Insurance Services (DNIS) is a Managing General Agent founded in 2002 and based in California.
• Our highly trained bilingual staff provide a unique experience in servicing agents and clients with a combined experience of over 30 years.
• We are a surplus lines insurance broker, licensed to operate in six states (AZ, CA, IL, NM, NV & TX).
• We work with the best insurance companies in Mexico such as
ANA Seguros, Quálitas & Zurich.
• Our network manages more than 20,000 satisfied agents in six states (AZ, CA, IL, NM, NV & TX).
LIC # 946598 ARIZONA
LIC # 0D95560 CALIFORNIA
LIC #<PHONE_NUMBER> ILLINOIS
LIC # 699776 NEVADA
LIC #100011806 NEW MEXICO
LIC # 15740053 TEXAS
Monday to Friday
9:00 - 18:00 hrs. PT
U.S.<PHONE_NUMBER>
MX<PHONE_NUMBER>


We redefine tables!
- enable out-of-the-box e-markets
- seize cross-media functionalities
- facilitate cutting-edge eyeballs
- integrate open-source supply-chains
- implement revolutionary mindshare
- optimize B2C users
- strategize compelling e-services
- innovate bricks-and-clicks infrastructures
- unleash user-centric architectures
- deploy sticky technologies
- implement world-class vortals
- scale dynamic solutions
- whiteboard rich e-services


Liar is a game made by Nicolas Froidure, lear more about him on his blog.
This game is released under the GNU/GPL licence, use it at your own risk !
Big thanks to people who made the sounds used by this game:
Here are a few game by the same author. Give a try !
| Name | Players | Type |
|---|---|---|
| Room 1 | 0/6 | Normal |
Please wait while connecting...
Sorry, but i was unable to connect to the server. Check your connection or retry later.
Who was the 15st president of the USA ?
John Kennedy - Bet : 1pt 2pt 3pt John Kennedy - Paul lie (+5pts)
Now waiting for other answers.
And, the winner is Pierre!
2th is Paul!
3rd Jack!
Then John!
Then Henri!


Programming:
C#, .net core, asp.net core, asp.net mvc, asp.net webapi, sql, dapper, entity framework core, Golang, C++
Front End:
Typescript, Javascript, Angular, node, Selenium
Tech:
Git, Teamcity, Octopus, Docker, Azure, IIS
Other:
Agile coaching, User Experience Research, APi design


--- layout: post title: "In the News: Against Personalization" date: 2017-11-08 18:45:00 +0000 tags: image: https://s3.amazonaws.com/audreywatters/2017-11-03-news.jpg imagecredits: https://www.flickr.com/photos/62693815@N03/6277209256 ---
As quoted in “The Case(s) Against Personalized Learning,” by Education Week’s Ben Herold:
K-12 educators and policymakers should question the forces driving that narrative, said Audrey Watters, an independent researcher who maintains the popular Hack Education blog.
The push for more personalized learning isn't happening in a vacuum, Watters maintained. The movement is emerging from the values and technologies that already define Silicon Valley. And it's clear how the companies behind those systems operate.
"When Facebook promises personalization," Watters said, "it's really about massive data collection."
I even got a pullquote:


A simple multi-service HTTP application deployed across multiple clusters using Skupper.
TCP data tunneled through a Skupper network from a private to a public site and back again.
Dynamically load balance HTTP requests across deployments on distinct clusters.
Deploy Istio's Bookinfo example app across multiple clusters.
Deploy the gRPC-based Hipster Shop example app across multiple clusters.
Deploy Kafka clients and clusters across multiple Kubernetes clusters without exposing Kafka ports.
Replicate a MongoDB database across multiple clusters.
Accessing a PostgreSQL database in the private cloud from the public cloud.
Gather Prometheus metrics from endpoints deployed across multiple clusters.


|
Houzi Game Engine
|
Namespace containing event related functions. More...
Typedefs | |
| using | timestamp = std::chrono::duration< uint32_t, std::milli > |
| Type for timestamps in events. More... | |
| using | quit_callback = std::function< void(timestamp)> |
| Callback function type for quit events. | |
| using | window_callback = std::function< void(timestamp, window::uid_type)> |
| Callback function type for generic window events. | |
| using | window_motion_callback = std::function< void(timestamp, window::uid_type, const vec2i &)> |
| Callback function type for window motion events. | |
| using | window_resize_callback = std::function< void(timestamp, window::uid_type, const vec2u &)> |
| Callback function type for window resize events. | |
| using | key_callback = std::function< void(timestamp, window::uid_type, scan_code, key_code, modifier_keys, bool)> |
| Callback function type for key events. | |
| using | mouse_button_callback = std::function< void(timestamp, window::uid_type, mouse_button, uint, const vec2i &)> |
| Callback function type for mouse button events. | |
| using | mouse_wheel_callback = std::function< void(timestamp, window::uid_type, const vec2i &, bool)> |
| Callback function type for mouse wheel events. | |
| using | mouse_motion_callback = std::function< void(timestamp, window::uid_type, mouse_buttons_state, const vec2i &, const vec2i &)> |
| Callback function type for mouse motion events. | |
| using | text_editing_callback = std::function< void(timestamp, window::uid_type, const static_string< 32u > &, int32_t, int32_t)> |
| Callback function type for text editing events. | |
| using | text_input_callback = std::function< void(timestamp, window::uid_type, const static_string< 32u > &)> |
| Callback function type for text input events. | |
Functions | |
| HOU_SYS_API void | wait_next () |
| Stops execution until an event is received, and then processes it. | |
| HOU_SYS_API bool | queue_empty () |
| Checks if the event queue is empty. More... | |
| HOU_SYS_API bool | process_next () |
| Processes the next event in the queue. More... | |
| HOU_SYS_API void | process_all () |
| Processes all events in the queue. | |
| HOU_SYS_API void | flush_all () |
| Removes all events from the queue without processing them. | |
| HOU_SYS_API void | set_quit_callback (quit_callback f) |
| Sets the callback for quit events. More... | |
| HOU_SYS_API void | generate_quit () |
| Generates an artificial quit event. | |
| HOU_SYS_API void | set_window_closed_callback (window_callback f) |
| Sets the callback for window closed events. More... | |
| HOU_SYS_API void | generate_window_closed (const window &w) |
| Generates an artificial window closed event. More... | |
| HOU_SYS_API void | set_window_hidden_callback (window_callback f) |
| Sets the callback for window hidden events. More... | |
| HOU_SYS_API void | generate_window_hidden (const window &w) |
| Generates an artificial window hidden event. More... | |
| HOU_SYS_API void | set_window_shown_callback (window_callback f) |
| Sets the callback for window shown events. More... | |
| HOU_SYS_API void | generate_window_shown (const window &w) |
| Generates an artificial window shown event. More... | |
| HOU_SYS_API void | set_window_exposed_callback (window_callback f) |
| Sets the callback for window exposed events. More... | |
| HOU_SYS_API void | generate_window_exposed (const window &w) |
| Generates an artificial window exposed event. More... | |
| HOU_SYS_API void | set_window_minimized_callback (window_callback f) |
| Sets the callback for window minimized events. More... | |
| HOU_SYS_API void | generate_window_minimized (const window &w) |
| Generates an artificial window minimized event. More... | |
| HOU_SYS_API void | set_window_maximized_callback (window_callback f) |
| Sets the callback for window maximized events. More... | |
| HOU_SYS_API void | generate_window_maximized (const window &w) |
| Generates an artificial window maximized event. More... | |
| HOU_SYS_API void | set_window_restored_callback (window_callback f) |
| Sets the callback for window restored events. More... | |
| HOU_SYS_API void | generate_window_restored (const window &w) |
| Generates an artificial window restored event. More... | |
| HOU_SYS_API void | set_window_focus_lost_callback (window_callback f) |
| Sets the callback for window focus lost events. More... | |
| HOU_SYS_API void | generate_window_focus_lost (const window &w) |
| Generates an artificial window focus lost event. More... | |
| HOU_SYS_API void | set_window_focus_gained_callback (window_callback f) |
| Sets the callback for window focus gained events. More... | |
| HOU_SYS_API void | generate_window_focus_gained (const window &w) |
| Generates an artificial window focus gained event. More... | |
| HOU_SYS_API void | set_window_focus_offered_callback (window_callback f) |
| Sets the callback for window focus offered events. More... | |
| HOU_SYS_API void | generate_window_focus_offered (const window &w) |
| Generates an artificial window focus offered event. More... | |
| HOU_SYS_API void | set_window_moved_callback (window_motion_callback f) |
| Sets the callback for window moved events. More... | |
| HOU_SYS_API void | generate_window_moved (const window &w, const vec2i &position) |
| Generates an artificial window moved event. More... | |
| HOU_SYS_API void | set_window_resized_callback (window_resize_callback f) |
| Sets the callback for window resized events. More... | |
| HOU_SYS_API void | generate_window_resized (const window &w, const vec2u &size) |
| Generates an artificial window resized event. More... | |
| HOU_SYS_API void | set_window_size_changed_callback (window_resize_callback f) |
| Sets the callback for window size changed events. More... | |
| HOU_SYS_API void | generate_window_size_changed (const window &w, const vec2u &size) |
| Generates an artificial window size changed event. More... | |
| HOU_SYS_API void | set_key_pressed_callback (key_callback f) |
| Sets the callback for key pressed events. More... | |
| HOU_SYS_API void | generate_key_pressed (const window &w, scan_code sc, key_code kc, modifier_keys mk, bool is_repeat) |
| Generates an artificial key pressed event. More... | |
| HOU_SYS_API void | set_key_released_callback (key_callback f) |
| Sets the callback for key released events. More... | |
| HOU_SYS_API void | generate_key_released (const window &w, scan_code sc, key_code kc, modifier_keys mk, bool is_repeat) |
| Generates an artificial key released event. More... | |
| HOU_SYS_API void | set_mouse_button_pressed_callback (mouse_button_callback f) |
| Sets the callback for mouse button pressed events. More... | |
| HOU_SYS_API void | generate_mouse_button_pressed (const window &w, mouse_button button, uint clicks, const vec2i &position) |
| Generates an artificial mouse button pressed event. More... | |
| HOU_SYS_API void | set_mouse_button_released_callback (mouse_button_callback f) |
| Sets the callback for mouse button released events. More... | |
| HOU_SYS_API void | generate_mouse_button_released (const window &w, mouse_button button, uint clicks, const vec2i &position) |
| Generates an artificial mouse button released event. More... | |
| HOU_SYS_API void | set_mouse_wheel_moved_callback (mouse_wheel_callback f) |
| Sets the callback for mouse wheel moved events. More... | |
| HOU_SYS_API void | generate_mouse_wheel_moved (const window &w, const vec2i &delta, bool flipped) |
| Generates an artificial mouse wheel moved event. More... | |
| HOU_SYS_API void | set_mouse_moved_callback (mouse_motion_callback f) |
| Sets the callback for mouse moved events. More... | |
| HOU_SYS_API void | generate_mouse_moved (const window &w, mouse_buttons_state mbs, const vec2i &position, const vec2i &position_delta) |
| Generates an artificial mouse moved event. More... | |
| HOU_SYS_API void | set_mouse_entered_callback (window_callback f) |
| Sets the callback for mouse entered events. More... | |
| HOU_SYS_API void | generate_mouse_entered (const window &w) |
| Generates an artificial mouse entered event. More... | |
| HOU_SYS_API void | set_mouse_left_callback (window_callback f) |
| Sets the callback for mouse left events. More... | |
| HOU_SYS_API void | generate_mouse_left (const window &w) |
| Generates an artificial mouse left event. More... | |
| HOU_SYS_API void | set_text_editing_callback (text_editing_callback f) |
| Sets the callback for text editing events. More... | |
| HOU_SYS_API void | generate_text_editing (const window &w, const static_string< 32u > &text, int32_t start, int32_t length) |
| Generates a text editing event. More... | |
| HOU_SYS_API void | set_text_input_callback (text_input_callback f) |
| Sets the callback for text input events. More... | |
| HOU_SYS_API void | generate_text_input (const window &w, const static_string< 32u > &text) |
| Generates a text input event. More... | |
Namespace containing event related functions.
| using hou::event::timestamp = typedef std::chrono::duration<uint32_t, std::milli> |
Type for timestamps in events.
The timestamp always refer to the time passed since the initialization of the system module.
| HOU_SYS_API void hou::event::generate_key_pressed | ( | const window & | w, |
| scan_code | sc, | ||
| key_code | kc, | ||
| modifier_keys | mk, | ||
| bool | is_repeat | ||
| ) |
Generates an artificial key pressed event.
| w | the window. |
| sc | the scan code. |
| kc | the key code. |
| mk | the modifier keys state. |
| is_repeat | whether this is a key repeat event or not. |
| HOU_SYS_API void hou::event::generate_key_released | ( | const window & | w, |
| scan_code | sc, | ||
| key_code | kc, | ||
| modifier_keys | mk, | ||
| bool | is_repeat | ||
| ) |
Generates an artificial key released event.
| w | the window. |
| sc | the scan code. |
| kc | the key code. |
| mk | the modifier keys state. |
| is_repeat | whether this is a key repeat event or not. |
| HOU_SYS_API void hou::event::generate_mouse_button_pressed | ( | const window & | w, |
| mouse_button | button, | ||
| uint | clicks, | ||
| const vec2i & | position | ||
| ) |
Generates an artificial mouse button pressed event.
| w | the window. |
| button | the mouse button. |
| clicks | the number of clicks. |
| position | the position of the mouse cursor relative to w. |
| HOU_SYS_API void hou::event::generate_mouse_button_released | ( | const window & | w, |
| mouse_button | button, | ||
| uint | clicks, | ||
| const vec2i & | position | ||
| ) |
Generates an artificial mouse button released event.
| w | the window. |
| button | the mouse button. |
| clicks | the number of clicks. |
| position | the position of the mouse cursor relative to w. |
| HOU_SYS_API void hou::event::generate_mouse_entered | ( | const window & | w | ) |
Generates an artificial mouse entered event.
| w | the window. |
| HOU_SYS_API void hou::event::generate_mouse_left | ( | const window & | w | ) |
Generates an artificial mouse left event.
| w | the window. |
| HOU_SYS_API void hou::event::generate_mouse_moved | ( | const window & | w, |
| mouse_buttons_state | mbs, | ||
| const vec2i & | position, | ||
| const vec2i & | position_delta | ||
| ) |
Generates an artificial mouse moved event.
| w | the window. |
| mbs | the mouse button state. |
| position | the final position of the mouse cursor relative to w. |
| position_delta | the difference between the final position of the mouse and the previous position of the mouse. |
| HOU_SYS_API void hou::event::generate_mouse_wheel_moved | ( | const window & | w, |
| const vec2i & | delta, | ||
| bool | flipped | ||
| ) |
Generates an artificial mouse wheel moved event.
| w | the window. |
| delta | the wheel delta movement. The x() component refers to the horizontal wheel, the y() component to the vertical wheel. |
| flipped | wheter the values in delta are flipped. |
| HOU_SYS_API void hou::event::generate_text_editing | ( | const window & | w, |
| const static_string< 32u > & | text, | ||
| int32_t | start, | ||
| int32_t | length | ||
| ) |
Generates a text editing event.
| w | the window. |
| text | the null-terminated editing text in UTF-8 encoding. |
| start | the location to begin editing from. |
| length | the number of characters to edit from the start point. |
| HOU_SYS_API void hou::event::generate_text_input | ( | const window & | w, |
| const static_string< 32u > & | text | ||
| ) |
Generates a text input event.
| w | the window. |
| text | the null-terminated input text in UTF-8 encoding. |
| HOU_SYS_API void hou::event::generate_window_closed | ( | const window & | w | ) |
Generates an artificial window closed event.
| w | the window. |
| HOU_SYS_API void hou::event::generate_window_exposed | ( | const window & | w | ) |
Generates an artificial window exposed event.
| w | the window. |
| HOU_SYS_API void hou::event::generate_window_focus_gained | ( | const window & | w | ) |
Generates an artificial window focus gained event.
| w | the window. |
| HOU_SYS_API void hou::event::generate_window_focus_lost | ( | const window & | w | ) |
Generates an artificial window focus lost event.
| w | the window. |
| HOU_SYS_API void hou::event::generate_window_focus_offered | ( | const window & | w | ) |
Generates an artificial window focus offered event.
| w | the window. |
| HOU_SYS_API void hou::event::generate_window_hidden | ( | const window & | w | ) |
Generates an artificial window hidden event.
| w | the window. |
| HOU_SYS_API void hou::event::generate_window_maximized | ( | const window & | w | ) |
Generates an artificial window maximized event.
| w | the window. |
| HOU_SYS_API void hou::event::generate_window_minimized | ( | const window & | w | ) |
Generates an artificial window minimized event.
| w | the window. |
Generates an artificial window moved event.
| w | the window. |
| position | the position. |
Generates an artificial window resized event.
| w | the window. |
| size | the size. |
| HOU_SYS_API void hou::event::generate_window_restored | ( | const window & | w | ) |
Generates an artificial window restored event.
| w | the window. |
| HOU_SYS_API void hou::event::generate_window_shown | ( | const window & | w | ) |
Generates an artificial window shown event.
| w | the window. |
Generates an artificial window size changed event.
| w | the window. |
| size | the size. |
| HOU_SYS_API bool hou::event::process_next | ( | ) |
Processes the next event in the queue.
If the queue is empty, no processing takes place.
| HOU_SYS_API bool hou::event::queue_empty | ( | ) |
Checks if the event queue is empty.
| HOU_SYS_API void hou::event::set_key_pressed_callback | ( | key_callback | f | ) |
Sets the callback for key pressed events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_key_released_callback | ( | key_callback | f | ) |
Sets the callback for key released events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_mouse_button_pressed_callback | ( | mouse_button_callback | f | ) |
Sets the callback for mouse button pressed events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_mouse_button_released_callback | ( | mouse_button_callback | f | ) |
Sets the callback for mouse button released events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_mouse_entered_callback | ( | window_callback | f | ) |
Sets the callback for mouse entered events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_mouse_left_callback | ( | window_callback | f | ) |
Sets the callback for mouse left events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_mouse_moved_callback | ( | mouse_motion_callback | f | ) |
Sets the callback for mouse moved events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_mouse_wheel_moved_callback | ( | mouse_wheel_callback | f | ) |
Sets the callback for mouse wheel moved events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_quit_callback | ( | quit_callback | f | ) |
Sets the callback for quit events.
Quit events are generated when the last window is closed, or by external events.
By default, when the sys module is initialized, signal handlers that generate a quit event are registered for SIGINT and SIGTERM.
| f | the callback. |
| HOU_SYS_API void hou::event::set_text_editing_callback | ( | text_editing_callback | f | ) |
Sets the callback for text editing events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_text_input_callback | ( | text_input_callback | f | ) |
Sets the callback for text input events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_window_closed_callback | ( | window_callback | f | ) |
Sets the callback for window closed events.
Window closed events are generated when a window object is destroyed or when the user clicks the window X button.
| f | the callback. |
| HOU_SYS_API void hou::event::set_window_exposed_callback | ( | window_callback | f | ) |
Sets the callback for window exposed events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_window_focus_gained_callback | ( | window_callback | f | ) |
Sets the callback for window focus gained events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_window_focus_lost_callback | ( | window_callback | f | ) |
Sets the callback for window focus lost events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_window_focus_offered_callback | ( | window_callback | f | ) |
Sets the callback for window focus offered events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_window_hidden_callback | ( | window_callback | f | ) |
Sets the callback for window hidden events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_window_maximized_callback | ( | window_callback | f | ) |
Sets the callback for window maximized events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_window_minimized_callback | ( | window_callback | f | ) |
Sets the callback for window minimized events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_window_moved_callback | ( | window_motion_callback | f | ) |
Sets the callback for window moved events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_window_resized_callback | ( | window_resize_callback | f | ) |
Sets the callback for window resized events.
Window resized events are generated when the window changes size due to external input, for example due to the user dragging the window borders.
| f | the callback. |
| HOU_SYS_API void hou::event::set_window_restored_callback | ( | window_callback | f | ) |
Sets the callback for window restored events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_window_shown_callback | ( | window_callback | f | ) |
Sets the callback for window shown events.
| f | the callback. |
| HOU_SYS_API void hou::event::set_window_size_changed_callback | ( | window_resize_callback | f | ) |
Sets the callback for window size changed events.
Window size changed events are generated when the window changes size for any reason.
| f | the callback. |


Let's play with X- and gamma-ray detectors
To make a simulation, first set the source and the detector, then push the "Run" buttom
Giovanni De Cesare |
|
Valentina Fioretti |
|
Fulvio Gianotti |
Luciano Nicastro |
|
Andrea Zoli |
|
Marco Malaspina |


|
Drake
|
A scalar multi-variate polynomial, modeled after the msspoly in spotless.
Polynomial represents a list of additive Monomials, each one of which is a product of a constant coefficient (of T, which by default is double) and any number of distinct Terms (variables raised to positive integer powers).
Variables are identified by integer indices rather than symbolic names, but an automatic facility is provided to covert variable names up to four characters into unique integers, provided those variables are named using only lowercase letters and the<EMAIL_ADDRESS>characters followed by a number. For example, valid names include "dx4" and "m_x".
Monomials which have the same variables and powers may be constructed but will be automatically combined: (3 * a * b * a) + (1.5 * b * a**2) will be reduced to (4.5 * b * a**2) internally after construction.
Polynomials can be added, subtracted, and multiplied. They may only be divided by scalars (of T) because Polynomials are not closed under division.
| T | The scalar type, which must be one of the default scalars. |
#include <drake/common/polynomial.h>
Classes | |
| class | Monomial |
| An additive atom of a Polynomial: The product of any number of Terms and a coefficient. More... | |
| struct | Product |
| class | Term |
| An individual variable raised to an integer power; e.g. x**2. More... | |
Public Types | |
| typedef unsigned int | VarType |
| typedef int | PowerType |
| This should be 'unsigned int' but MSVC considers a call to std::pow(..., unsigned int) ambiguous because it won't cast unsigned int to int. More... | |
| typedef Eigen::NumTraits< T >::Real | RealScalar |
| typedef std::complex< RealScalar > | RootType |
| typedef Eigen::Matrix< RootType, Eigen::Dynamic, 1 > | RootsType |
Public Member Functions | |
| Polynomial (void) | |
| Construct the vacuous polynomial, "0". More... | |
| Polynomial (const T &scalar) | |
| Construct a Polynomial of a single constant. e.g. "5". More... | |
| Polynomial (const T coeff, const std::vector< Term > &terms) | |
| Construct a Polynomial consisting of a single Monomial, e.g. "5xy**3". More... | |
| Polynomial (typename std::vector< Monomial >::const_iterator start, typename std::vector< Monomial >::const_iterator finish) | |
| Construct a Polynomial from a sequence of Monomials. More... | |
| template<typename U = T> | |
| Polynomial (const std::enable_if_t< std::is_same_v< U, double >, std::string > &varname) | |
Constructs a polynomial consisting of a single Monomial of the variable named varname1 . More... | |
| Polynomial (const std::string &varname, unsigned int num) | |
| Construct a polynomial consisting of a single Monomial of the variable named varname + num. More... | |
| Polynomial (const T &coeff, const VarType &v) | |
| Construct a single Monomial of the given coefficient and variable. More... | |
| template<typename Derived > | |
| Polynomial (Eigen::MatrixBase< Derived > const &coefficients) | |
| A legacy constructor for univariate polynomials: Takes a vector of coefficients for the constant, x, x**2, x**3... More... | |
| int | GetNumberOfCoefficients () const |
| Returns the number of unique Monomials (and thus the number of coefficients) in this Polynomial. More... | |
| int | GetDegree () const |
| Returns the highest degree of any Monomial in this Polynomial. More... | |
| bool | IsAffine () const |
| Returns true iff this is a sum of terms of degree 1, plus a constant. More... | |
| VarType | GetSimpleVariable () const |
| If the polynomial is "simple" – e.g. More... | |
| const std::vector< Monomial > & | GetMonomials () const |
| Eigen::Matrix< T, Eigen::Dynamic, 1 > | GetCoefficients () const |
| std::set< VarType > | GetVariables () const |
| Returns a set of all of the variables present in this Polynomial. More... | |
| template<typename U > | |
| Product< T, U >::type | EvaluateUnivariate (const U &x, int derivative_order=0) const |
| Evaluate a univariate Polynomial at a specific point. More... | |
| template<typename U > | |
| Product< T, U >::type | EvaluateMultivariate (const std::map< VarType, U > &var_values) const |
| Evaluate a multivariate Polynomial at a specific point. More... | |
| Polynomial | EvaluatePartial (const std::map< VarType, T > &var_values) const |
| Substitute values for some but not necessarily all variables of a Polynomial. More... | |
| void | Subs (const VarType &orig, const VarType &replacement) |
| Replaces all instances of variable orig with replacement. More... | |
| Polynomial | Substitute (const VarType &orig, const Polynomial &replacement) const |
| Replaces all instances of variable orig with replacement. More... | |
| Polynomial | Derivative (int derivative_order=1) const |
| Takes the derivative of this (univariate) Polynomial. More... | |
| Polynomial | Integral (const T &integration_constant=0.0) const |
| Takes the integral of this (univariate, non-constant) Polynomial. More... | |
| bool | operator== (const Polynomial &other) const |
| Polynomial & | operator+= (const Polynomial &other) |
| Polynomial & | operator-= (const Polynomial &other) |
| Polynomial & | operator *= (const Polynomial &other) |
| Polynomial & | operator+= (const T &scalar) |
| Polynomial & | operator-= (const T &scalar) |
| Polynomial & | operator *= (const T &scalar) |
| Polynomial & | operator/= (const T &scalar) |
| const Polynomial | operator+ (const Polynomial &other) const |
| const Polynomial | operator- (const Polynomial &other) const |
| const Polynomial | operator- () const |
| const Polynomial | operator * (const Polynomial &other) const |
| const Polynomial | operator/ (const T &scalar) const |
| bool | operator< (const Polynomial &other) const |
| A comparison to allow std::lexicographical_compare on this class; does not reflect any sort of mathematical total order. More... | |
| RootsType | Roots () const |
| Returns the roots of this (univariate) Polynomial. More... | |
| boolean< T > | CoefficientsAlmostEqual (const Polynomial< T > &other, const RealScalar &tol=0.0, const ToleranceType &tol_type=ToleranceType::kAbsolute) const |
| Checks if a Polynomial is approximately equal to this one. More... | |
Implements CopyConstructible, CopyAssignable, MoveConstructible, MoveAssignable | |
| Polynomial (const Polynomial &)=default | |
| Polynomial & | operator= (const Polynomial &)=default |
| Polynomial (Polynomial &&)=default | |
| Polynomial & | operator= (Polynomial &&)=default |
Static Public Member Functions | |
| static Polynomial< T > | FromExpression (const drake::symbolic::Expression &e) |
Constructs a Polynomial representing the symbolic expression e . More... | |
| static bool | IsValidVariableName (const std::string name) |
| Variable name/ID conversion facility. More... | |
| static VarType | VariableNameToId (const std::string name, unsigned int m=1) |
| static std::string | IdToVariableName (const VarType id) |
Friends | |
| const Polynomial | operator+ (const Polynomial &p, const T &scalar) |
| const Polynomial | operator+ (const T &scalar, const Polynomial &p) |
| const Polynomial | operator- (const Polynomial &p, const T &scalar) |
| const Polynomial | operator- (const T &scalar, const Polynomial &p) |
| const Polynomial | operator * (const Polynomial &p, const T &scalar) |
| const Polynomial | operator * (const T &scalar, const Polynomial &p) |
| std::ostream & | operator<< (std::ostream &os, const Monomial &m) |
| std::ostream & | operator<< (std::ostream &os, const Polynomial &poly) |
| template<typename U > | |
| Polynomial< U > | pow (const Polynomial< U > &p, typename Polynomial< U >::PowerType n) |
This should be 'unsigned int' but MSVC considers a call to std::pow(..., unsigned int) ambiguous because it won't cast unsigned int to int.
| typedef Eigen::NumTraits<T>::Real RealScalar |
| typedef std::complex<RealScalar> RootType |
|
default |
|
default |
| Polynomial | ( | void | ) |
Construct the vacuous polynomial, "0".
| Polynomial | ( | const T & | scalar | ) |
Construct a Polynomial of a single constant. e.g. "5".
| Polynomial | ( | const T | coeff, |
| const std::vector< Term > & | terms | ||
| ) |
Construct a Polynomial consisting of a single Monomial, e.g. "5xy**3".
| Polynomial | ( | typename std::vector< Monomial >::const_iterator | start, |
| typename std::vector< Monomial >::const_iterator | finish | ||
| ) |
Construct a Polynomial from a sequence of Monomials.
|
explicit |
Constructs a polynomial consisting of a single Monomial of the variable named varname1
.
Polynomial<T>(0)
as the following candidates are ambiguous:| Polynomial | ( | const std::string & | varname, |
| unsigned int | num | ||
| ) |
Construct a polynomial consisting of a single Monomial of the variable named varname + num.
| Polynomial | ( | const T & | coeff, |
| const VarType & | v | ||
| ) |
Construct a single Monomial of the given coefficient and variable.
|
explicit |
A legacy constructor for univariate polynomials: Takes a vector of coefficients for the constant, x, x**2, x**3...
Monomials.
| boolean<T> CoefficientsAlmostEqual | ( | const Polynomial< T > & | other, |
| const RealScalar & | tol = 0.0 , |
||
| const ToleranceType & | tol_type = ToleranceType::kAbsolute |
||
| ) | const |
Checks if a Polynomial is approximately equal to this one.
Checks that every coefficient of other
is within tol
of the corresponding coefficient of this Polynomial.
Note: When tol_type
is kRelative, if any monomials appear in this
or other
but not both, then the method returns false (since the comparison is relative to a missing zero coefficient). Use kAbsolute if you want to ignore non-matching monomials with coefficients less than tol
.
| Polynomial Derivative | ( | int | derivative_order = 1 | ) | const |
Takes the derivative of this (univariate) Polynomial.
Returns a new Polynomial that is the derivative of this one in its sole variable.
| std::exception | if this Polynomial is not univariate. |
If derivative_order is given, takes the nth derivative of this Polynomial.
Evaluate a multivariate Polynomial at a specific point.
Evaluates a Polynomial with the given values for each variable.
| std::out_of_range | if the Polynomial contains variables for which values were not provided. |
The provided values may be of any type which is std::is_arithmetic (supporting the std::pow, *, and + operations) and need not be CoefficientsType or RealScalar)
| Polynomial EvaluatePartial | ( | const std::map< VarType, T > & | var_values | ) | const |
Substitute values for some but not necessarily all variables of a Polynomial.
Analogous to EvaluateMultivariate, but: (1) Restricted to T, and (2) Need not map every variable in var_values.
Returns a Polynomial in which each variable in var_values has been replaced with its value and constants appropriately combined.
Evaluate a univariate Polynomial at a specific point.
Evaluates a univariate Polynomial at the given x.
| std::runtime_error | if this Polynomial is not univariate. |
x
may be of any type supporting the ** and + operations (which can be different from both CoefficientsType and RealScalar).
This method may also be used for efficient evaluation of the derivatives of the univariate polynomial, evaluated at x
. derivative_order
= 0 (the default) returns the polynomial value without differentiation. derivative_order
= 1 returns the first derivative, etc.
|
static |
Constructs a Polynomial representing the symbolic expression e
.
Note that the ID of a variable is preserved in this translation.
| std::runtime_error | if e is not polynomial-convertible. |
| Eigen::Matrix<T, Eigen::Dynamic, 1> GetCoefficients | ( | ) | const |
| int GetDegree | ( | ) | const |
Returns the highest degree of any Monomial in this Polynomial.
The degree of a multivariate Monomial is the product of the degrees of each of its terms.
| const std::vector<Monomial>& GetMonomials | ( | ) | const |
| int GetNumberOfCoefficients | ( | ) | const |
Returns the number of unique Monomials (and thus the number of coefficients) in this Polynomial.
| VarType GetSimpleVariable | ( | ) | const |
If the polynomial is "simple" – e.g.
just a single term with coefficient 1 – then returns that variable; otherwise returns 0.
| std::set<VarType> GetVariables | ( | ) | const |
Returns a set of all of the variables present in this Polynomial.
|
static |
| Polynomial Integral | ( | const T & | integration_constant = 0.0 | ) | const |
Takes the integral of this (univariate, non-constant) Polynomial.
Returns a new Polynomial that is the indefinite integral of this one in its sole variable.
| std::exception | if this Polynomial is not univariate, or if it has no variables. |
If integration_constant is given, adds that constant as the constant term (zeroth-order coefficient) of the resulting Polynomial.
| bool IsAffine | ( | ) | const |
Returns true iff this is a sum of terms of degree 1, plus a constant.
|
static |
Variable name/ID conversion facility.
| const Polynomial operator * | ( | const Polynomial< T > & | other | ) | const |
| Polynomial& operator *= | ( | const Polynomial< T > & | other | ) |
| Polynomial& operator *= | ( | const T & | scalar | ) |
| const Polynomial operator+ | ( | const Polynomial< T > & | other | ) | const |
| Polynomial& operator+= | ( | const Polynomial< T > & | other | ) |
| Polynomial& operator+= | ( | const T & | scalar | ) |
| const Polynomial operator- | ( | const Polynomial< T > & | other | ) | const |
| const Polynomial operator- | ( | ) | const |
| Polynomial& operator-= | ( | const Polynomial< T > & | other | ) |
| Polynomial& operator-= | ( | const T & | scalar | ) |
| const Polynomial operator/ | ( | const T & | scalar | ) | const |
| Polynomial& operator/= | ( | const T & | scalar | ) |
| bool operator< | ( | const Polynomial< T > & | other | ) | const |
A comparison to allow std::lexicographical_compare on this class; does not reflect any sort of mathematical total order.
|
default |
|
default |
| bool operator== | ( | const Polynomial< T > & | other | ) | const |
| RootsType Roots | ( | ) | const |
Returns the roots of this (univariate) Polynomial.
Returns the roots of a univariate Polynomial as an Eigen column vector of complex numbers whose components are of the RealScalar type.
| std::exception | of this Polynomial is not univariate. |
Replaces all instances of variable orig with replacement.
| Polynomial Substitute | ( | const VarType & | orig, |
| const Polynomial< T > & | replacement | ||
| ) | const |
Replaces all instances of variable orig with replacement.
|
friend |
|
friend |
|
friend |
|
friend |
|
friend |
|
friend |
|
friend |
|
friend |
|
friend |


This is a dummy page that helps us demonstrate reusable CSS stylesheets. Go back.
Want to try crossing out an obsolete link? This is your chance!


Edit & Update
nickname
First Name
Last Name
Email
Phone
Password
City
State
Bowling average:
The highlight of last year was...
Whats your favorite sports tesm?
How do you know me?
Recent News
Smack Talk!
startpage
Update User


Wataru 'Wat' Misaka, trailblazing player who broke NBA's color barrier, dies at 95
LOS ANGELES – Wataru “Wat” Misaka, a Utah native of Japanese descent who was recognized as the first person of color to play in what is now the NBA, died Wednesday at the age of 95, the University of Utah said.
Misaka, who was born in Ogden, Utah, played for Weber Junior College in his hometown before playing at the University of Utah — where he helped the team to victory over Dartmouth in the 1944 NCAA championship game at Madison Square Garden.
After helping Utah to another national title, Misaka joined the NBA predecessor Basketball Association of America. The NBA includes the BAA’s statistics in its history.
“We are saddened to learn of the passing of Wat Misaka,” said University of Utah Director of Athletics Mark Harlan.
“He was a part of the Utah teams that won national championships in the 1940s, but Wat was bigger than the game of basketball, blazing trails into places nobody of his descent had gone before.
RELATED STORIES
“He was such a kind and thoughtful man and will be missed by so many.”
In between two seasons playing for Utah, Misaka was drafted into the U.S. military and rose to the rank of staff sergeant.
He was drafted by the New York Knicks in 1947 and played three games — scoring seven points — in the 1947-48 season.
In 2009, U.S. President Barack Obama mentioned Misaka when he spoke at the opening ceremony to mark the formation of the President’s Advisory Commission and White House Initiative on Asian Americans and Pacific Islanders.
His life was documented in the movie “Transcending: The Wat Misaka Story.”
“Wat was a person who was an achiever in all he did,” said Misaka’s Utah teammate Arnie Ferrin.
“He did so many great things such as representing the Japanese as an American citizen during the War. He was one of my best friends, in fact we all should have a friend like him. I will miss him dearly.”
GET THE BEST OF THE JAPAN TIMES IN FIVE EASY PIECES WITH TAKE 5
JOIN THE CONVERSATION


{% extends "base.html" %} {% block title %}Contact{% endblock %} {% block content %}
Meet us in IRC on irc.freenode.org#bacongamejam
Most of us will be in the channel during the jams, but you can meet a few of us outside jamming time. Feel free to ask any questions about the jam, or just join to chat.
For discussions, ideas, feedback, questions, and anything related to the game jam in general, please create a post over at reddit.


| DOSE: |
10 mg |
IV |
Pharms - Nalbuphine |
(liquid) |
My first experience with opiates came via a source who supplied some rather unknown pharmaceuticals including nalbuphine (Nubain) and butorphanol (Stadol). Although pretty much unheard of among most of my psychonaut friends, these painkillers seem to be the opiate of choice for the bodybuilding drug scene.
Both of these drugs come in liquid form only, an advantage to needle-fiends like myself. Although I suppose there shouldn't be any reason it can't be baked up and snorted.
They are also both partial opiate agonists and for that reason are considered to have relatively low 'abuse potentials' as far as opiates go. What this tends to mean for the user is (1) they are going to be infinitely easier to get than any other heavy duty pharmaceutical meant for injection and (2) while they may not be as fully opiate-like in their feel, and could be somewhat unpleasant at first, if used properly they can be very pleasant and fun (more than their scheduling would suggest anyway).
I was originally introduced to butorphanol in its veterinary form (known as Torbugesic, and other than the name, seems to be identical to its human version: Stadol).
A friend of mine administered an injection (of a typical dose, something equivalent to 10mg of morphine). I wasn't in any particular kind of mood, and I was anticipating something pleasant. I began to feel ill. Mostly nauseous but just generally crappy. I got a vial of the stuff and just held onto it. I had no real desire to try it again and I wasn't going to throw something so interesting away. Finally curiousity got the better of me and I tried it again. Almost none of the previous unpleasant effects took place. It produced a much more opiate-like feel. It was probably a combination of trying a smaller dose and building a tolerance to the nauseating effects, but it had a completely new feel to it that really surprised me.
I proceeded to go through the vial pretty quickly. Never did too much of the stuff at once, but I did it a lot. When I ran out after maybe 2 weeks, I was expecting to be kicking the stuff for at least a few days before I felt good or normal again. But the stuff was pretty sparing as far as withdrawls go.
Eventually I got my hands on some Nubain. This stuff was mg/mg equivalent to morphine while still being only a partial agonist/antagonist. While supposedly similar to butorphanol, this stuff was a much smoother buzz. It seemed to have more of the peaceful, calm, confident trancelike effects you get with normal opiates. Never had a bad experience with it except for getting slightly hooked, but again, getting off them isn't too hard.
A friend of mine, one of the few privy to my habit, wanted to try some, so I obliged. She seemed to experience the same unpleasant effects I had with my first couple butor experiences. The unpleasantness definitely faded but didn't completely disappear with use. She experienced similar discomfort (stomach upset mostly) with other opiates (oxycodone, hydrocodone and such). Whereas after the first few times, I never had any nausea or pains from opiates ever again. I guess people have different sensitivities. I would think if you react well to opiates in general, you'll probably like the partials as well.
Having tried just about every other pharmaceutical grade opiate since then, I'd say nubain, and to a lesser degree, butorphanol are two of my favorites. They can be somewhat addictive, but withdrawls seem to be slight if at all noticable. I never found myself increasing my dose or building much of a noticable tolerance even with 2-3 weeks of pretty regular use. Partials also seem to reach a dose-response peak unlike normal opiates. This means that after a point, taking more simply won't give you more of a high. I never seemed to need more than the standard 10mg equivalent.
At any rate, they're a lot more fun than they're given credit for. If you simply can't control your hankering for trying something IV, you're probably a lot better off trying these than injecting pills or some whoknowswhat mystery street powder.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Provides Classes and Interfaces for handling mappings, repositories, vocabulary target definitions and source and output of the mapping process.


--- layout: archive title: Zulip Chat Archive permalink: /stream/116395-maths/topic/-1.20raised.20to.20an.20integer.html ---
What's the best way of writing (-1) ^ n
where n : int
? You can't just write it as is since has_pow int int
doesn't exist (and shouldn't of course). Is there some construct in mathlib for this?
I guess the best way depends on your application, but the reason -1
to a power is allowed is because -1
is a unit in the ring Z so one way would be
variable (n : ℤ) #check (-1 : units ℤ) ^ n #eval (-1 : units ℤ) ^ (-4 : ℤ)
Oh very interesting. I'll try this. Thank you
Hmm, is it obvious why ring_exp
can't handle this?
example (n : ℕ) : ((-1 : units ℤ) ^ (n + 1)) = (-1 : units ℤ) * ((-1 : units ℤ) ^ n) := by ring_exp
units ℤ
isn't a ring
it's also overkill for this example. There is a lemma that says exactly this; use library_search
to find it
library_search
suggests I just use rfl
, which I guess makes sense depending on how pow
is implemented on succ n
. Thanks!
Last updated: Apr 24 2020 at 19:02 UTC


What is Pair Programming?
Pair programming is a way of developing software which involves two or more programmers sitting side
by side in order to create more efficient and cleaner code. By having two people work together, pair programming ensures
quality by having one programmer drive (type the code), and one programmer navigate (dictate the flow). Both programmers collaborate
on the tactics and strategy behind the code. It is a best practice for these programmers to switch between these roles.
Why is Pair Programming Important to DBC?
Pair programming is important to DBC for several reasons.
1. It produces better code
2. It is how many real world programming works
3. It encourages multiple viewpoints and alternative problem solving
4. It helps to develop collaborate interpersonal skills
Driver Vs Navigator
Driver
The driver is the one who writes the code. Drivers focus on writing each specific line of code, while
making syntactical decisions. They make the tactical decisions on solving the task at hand.
Navigator
The navigator reviews each line as it is typed in. While reviewing, they consider more of a strategic direction
and think of improvements as well as the bigger picture.
My First Pairing Experience
My first pairing experience was like dipping my toes in water for the first time. It was a little slow at first while we were getting a feel for how our partner likes to work. There was constant communication and clear role designation in the beginning which helped drive us to get rolling on our task. I realized later down the road that I should have looked over some of the material we agreed to work on so that I wouldn't be so lost. Despite this, my partner was kind enough to patiently explain some of the material as I drove like a teen behind the wheel of a car for the first time. The clear role designation definitely helped us to know what we should be doing, and as we grew comfortable adjusting to our roles, it was smooth sailing by the end.


{% extends "bank/base.html" %} {% block body %}
You can be an employee of as many organization as you wish. The owner of an organization can invite you to join them, and you can accept or decline their invitation here.
You're not employed anywhere.


Jennifer Aniston celebrates ‘Friendsgiving’ with ex-husband Justin Theroux
The pair were joined by a host of their famous pals
by Kendra BeckerJennifer Aniston celebrated ‘Friendsgiving’ with her ex-husband Justin Theroux, just months after finalising their divorce.
The former couple were joined by a host of their celebrity pals as Jen hosted a Friendsgiving feast, the day before actual Thanksgiving.
Stars including Courteney Cox, Jimmy Kimmel, Jason Bateman and Will Arnett were all spotted at the dinner party, in photos and videos posted by Justin on Instagram.
Jennifer also shared photos from their Friendsgiving party, including a snap of her making enchiladas for chat show host Jimmy.
Last year on his show, Jimmy said people should only eat Mexican food on Friendsgiving, to save the traditional turkey and stuffing for Thanksgiving day.
Poking fun at Jimmy’s request, the actress made Jimmy a popular Mexican dish, and named it, “Jimmy’s f**king enchiladas.”


--- layout: default ---
{% if page.image_credit %}
Photo: {{ page.image_credit }}
{% endif %}
Livestream @ 7pm {% if page.agenda %} Agenda {% endif %}
{% for p in page.speakers %}
{{p}}
{% endfor %}
Closed Captioning YouTube automatic closed captioning will be available on our YouTube Livestream.
ASLThis event will {% unless page.asl_provided %} not {% endunless %}have an American Sign Language interpreter.
Civic hacking After the presentation, we will break out into learning and prototyping groups.
{% endif %}
{% for p in page.speakers %}
{{p}}
{% endfor %}


Event Location:
Ohio Dominican University
1216 Sunbury Road
Columbus, Ohio
Abstract:
If you’re like me, you’ve been using SQL Trace and Profiler since you started using SQL Server. They’re like old friends, tried and true. You know how they work, you know what you can capture, you know how to find the data you need. But now you’ve been told that your good friends have been deprecated in SQL Server 2012, and you need to become best friends with Extended Events. What is THAT all about? It’s ok. Really. In this session we’ll look at Profiler and Extended Events side by side to see how easy it is to transition to Extended Events. We’ll step through real world examples using Extended Events to do what you’re used to doing with Trace, and even more. You can find the time learn Extended Events…today.
Speaker(s): Erin Stellato,
Abstract:
You've upgraded to better hardware, tuned your queries, and busy seasons is still six months away; you should be resting easy. But reports are running too long, SQL Server is under a heavy load, and you're not sure how you'll keep up with the demands of customers, much less the rest of the business. I've been there before. By moving functionality into Hadoop, I've been able to scale the database bigger and faster than previously possible; small incremental improvements became massive linear improvements and I delivered functionality that was previously thought to be impractical. In this session, I'll cover patterns, strategies, and use cases to increase reporting and analytics performance using Hadoop.
Speaker(s): Jeremiah Peschka,
Abstract:
When you have one SQL Server instance to maintain, you can give that instance plenty of TLC. When you have a hundred instances, many things which worked before simply will not scale, potentially leaving your databases in peril. The next step (after justifiable panic) is to give yourself a force multiplier to help you keep your sanity on the job--specifically, an administrative database. This session will give you an idea of what kinds of tools should go into an administrative database, as well as how to use this to collect important metrics for reporting and auditing. Audience participation from more advanced database administrators is encouraged: we want to find out what's in YOUR DB wallet.
Speaker(s): Kevin Feasel,
Abstract:
When creating an SSIS package, it is best practice to follow some kind of template. The package configuration needs to be set up. Logging needs to be set up. The work that you do to set up this template is tedious at best. In this session we will develop a template SSIS package using BIML. BIML is an XML markup language designed for representing the structure of an SSIS package. BIML Script takes that structure and generates an SSIS package. We will create a package that has some specific connection strings. We will tie those connection strings to configuration settings. Then we will add custom logging. We will then build individual SSIS packages to copy a list of tables to their destination.
Speaker(s): Russel Loski,
Abstract:
As the most prolific inventor in American history, Thomas Edison was a master of “Best Practices!” Edison’s creations were not just novel and commercially successful, but many launched entire new industries including electric light and power, sound recording, motion pictures and industrial cement and concrete manufacture. At the heart of Edison’s remarkable record of innovation was his categorization of the innovation process into “competencies,” or bundles of skills supporting the achievement of success in a particular area of endeavor. In this session, we will look at ways that we can use many of these broad success secrets to bring powerful tools and strategies to the recurring implementation of business intelligence.
Speaker(s): William E Pearson III,
Abstract:
Database statistics are not made up numbers, like the statistics you may hear on TV or read in a news article. They are critical metadata used by SQL Server’s query optimizer. In this session, we will look at statistics from the ground up and remove the mystery that surrounds them. Demos and real-world examples will be used to explain what statistics are, why you should care about them, and what you can control. By the end of the session, you will understand: • How to view statistics and interpret the histogram • How and when to update statistics • How statistics affect the query optimizer • When you can let SQL Server manage statistics, and when you need to step in
Speaker(s): Erin Stellato,
Abstract:
The Analysis Services 2012 Business Intelligence Semantic Model (BISM) unifies Multidimensional (OLAP) and Tabular (relational) options for organizational BI. BI professionals can implement Multidimensional cubes, or they can deploy Tabular models, developed by business users, to a dedicated server. Those new to Tabular, or those embarking upon BI for the first time with Analysis Services 2012, may find it difficult to choose between the two paths. In this session, BI Architect and MVP Bill Pearson overviews the nature and design goals of each option, comparing Multidimensional and Tabular features. He then offers guidance on selecting the appropriate model, providing real world examples to illustrate approaches for given scenarios.
Speaker(s): William E Pearson III,
Abstract:
We all know how important it is to keep a baseline of performance metrics that allow us to know when something is wrong and help us to track it down and fix the problem. We don't always know how to do this easily and consistently. This session will walk you through a series of PowerShell scripts you can schedule which will capture the most important data and a set of reports to show you how to use that data to keep your server running smoothly.
Speaker(s): Allen White,
Abstract:
This presentation is for absolute beginners to Integration Services, giving the bare essentials to start working in this environment with confidence. We’ll cover basic architecture, basic development, and basic administration in one hour! List of scary acronyms and terms on the list for “demystification”: SSIS, BIDS, ETL, Configurations, Package Deployment, Package Execution, SQL Server Agent.
Speaker(s): Julie Smith,
Abstract:
The more you have to manage, the more likely you'll want to automate your processes. PowerShell is the scripting language that will make you truly effective at managing lots of servers. This session will introduce you to PowerShell and show you how to use it to manage SQL Server across many instances.
Speaker(s): Allen White,
Abstract:
SQL Server query tuning is often more art than science and it can quickly eat up a lot of DBA and/or Developer time. This presentation will outline a method for determining the best approach for tuning queries by utilizing response time analysis and SQL diagramming techniques. Regardless of the complexity of the statement, this quick, systematic approach will lead you down the correct tuning path with no guessing.
Speaker(s): Janis Griffin,
Abstract:
How many times have you started a new SSIS project and added the same components that you’ve added to almost every other package you’ve created? Components to handle logging and errors or even a standard workflow for loading data files. In this session I’ll show you how you can create standard templates that already contain any and all of the common components you desire. We’ll also look at how to implement and use these templates so that the next time you create a SSIS package you can spend your time on the work you actually need to do instead of implementing common components over and over again.
Speaker(s): Brian Davis,
Abstract:
SQL Server Extended Events can be used to gather a wide range of performance information, and in troubleshooting in SQL Server. Extended Events use less system resources and provide better information than SQL Profiler and they allow for correlation of SQL Server event data along side of OS or Application event data. This presentation will explore what Extended Events are, how to set them up and use them in several case studies.
Speaker(s): Janis Griffin,
Abstract:
Another in TheSQLGuru's very popular "Deep Dive" series, this time covering indexing. You will learn about the internal structures of heaps, clustered indexes and nonclustered indexes. We will examine included columns and covering indexes, filtered indexes, indexed views, indexing DMVs and finding the right indexes. There are some incredibly helpful graphics as well as some nice samples to help you transition theory to practice.
Speaker(s): Kevin Boles,
Abstract:
Yeah, it has an arcane syntax - but that is why we have templates and snippets! :-P Merge is a very powerful TSQL construct that can both simplify your code and help with some otherwise difficult maneuvers such as the classic "Upsert".
Speaker(s): Kevin Boles,
Abstract:
By now you've probably heard the words "Big Data" and "Hadoop", but you're not sure what they mean, much less how to get started. Maybe you're struggling with storing a lot of data, rapidly processing a huge volume of data, or maybe you're just curious. There are a bewildering array of options and use cases within the Hadoop ecosystem. Every day I help customers understand their data problems, understand where Hadoop fits into their environment, and determine how they can use Hadoop to solve their problem. This session provides an introduction to what Hadoop is, when it's appropriate to use Hadoop, and guidance on how to get started.
Speaker(s): Jeremiah Peschka,
Abstract:
When and how was this view changed? Where did that index go? Who's accessing my sensitive data? In this demo-heavy session, we'll explore various methods of auditing events in SQL Server, how they work, and the inherent strengths and shortcomings of each in an epic quest to find the perfect SQL Server auditing solution.
Speaker(s): Colleen Morrow,
Abstract:
The 2012 release of SQL Server introduces 14 new functions for developers. This list includes functions for conversion, date/time calculation, enhanced logic, and string manipulation. In this session we’ll cover the ins and outs of these new functions, making you a better T-SQL developer.
Speaker(s): Sam Nasr,
Abstract:
Custom proximity search is a new feature introduced in SQL Server 2012 Full-Text Search. It's facilitated using the NEAR operator, allowing it to be used in the CONTAINS predicate or CONTAINSTABLE function. The NEAR operator allows for searching words near each other. It also allows the user to specify the maximum number of non-search terms separating the first and last search terms in a match. In addition, an optional parameter can be used to specify an exact order match.
Speaker(s): Sam Nasr,
Abstract:
Let's face it, auditing isn't fun.  Fortunately, SQL Audit makes it easy. In this session, we'll cover what you can and can't audit using SQL Audit, enhancements in 2012, configuring database and server audits, ways to process output, and ideas for how to implement SQL Audit on a larger scale. Auditing doesn't have to be hard. And with the help of a little custom coding, it can even be fun.
Speaker(s): Colleen Morrow,
This is a list of speakers from the XML Guidebook records. The details and URLs were valid at the time of the event.
LinkedIn: https://www.linkedin.com/e/fpf/252170891
Contact: https://mvp.support.microsoft.com/profile=02C5CD07-7511-4151-A678-3A4A3451F85E
Bill Pearson created Island Technologies Inc. in 1997, and has developed a large and diverse customer base since. Bill#39;s background as a CPA, Internal Auditor, Management Accountant, and SQL Server MVP (BI) enables him to provide value to clients as a liaison between Accounting / Finance and Information Services. Bill has implemented enterprise business intelligence systems over the years for many Fortune 500 companies and focuses his practice upon the integrated Microsoft Business Intelligence
LinkedIn: http://www.linkedin.com/pub/allen-white-sql-server-mvp/5/784/b08/
Contact: http://dataperfpro.com/blog/
Allen White is a Data Platform consultant. He has been both a developer and an administrator, so he understands both perspectives towards database technology. He loves sharing his experiences and helping people learn how to use SQL Server. Allen has spent over 40 years in IT, using SQL Server since 1992, and has been awarded Microsoft’s MVP Award for the last 13 years. Allen was a PASS Director from 2016 - 2018.
LinkedIn: http://www.linkedin.com/in/erinstellato
Contact: http://www.sqlskills.com/blogs/erin
Erin Stellato is a Data Platform MVP and lives outside Cleveland, OH. She has almost 20 years of technology experience and has worked with SQL Server since 2003. Her areas of interest include performance tuning, Query Store, Extended Events, and helping accidental/involuntary DBAs understand how SQL Server works. Erin is an active member of the SQL Server community, has volunteered for PASS at the local and national level, and is a regular speaker at conferences including the PASS Summit, SQLIntersection, and SQLBits. Outside of time with family and friends, she enjoys running, spinning, movies, and all things chocolate.
LinkedIn: https://www.linkedin.com/e/fpf/252170891
Contact: https://mvp.support.microsoft.com/profile=02C5CD07-7511-4151-A678-3A4A3451F85E
Bill Pearson created Island Technologies Inc. in 1997, and has developed a large and diverse customer base since. Bill#39;s background as a CPA, Internal Auditor, Management Accountant, and SQL Server MVP (BI) enables him to provide value to clients as a liaison between Accounting / Finance and Information Services. Bill has implemented enterprise business intelligence systems over the years for many Fortune 500 companies and focuses his practice upon the integrated Microsoft Business Intelligence
LinkedIn: http://www.linkedin.com/pub/janis-griffin/0/914/aba
Janis Griffin has over 30 years of DBA/database experience including design, development and implementation of many critical database applications. Before coming to Quest Software, Janis primarily worked in the Telecom/Network Industry, working with both real-time network routing databases and OLTP business to business applications. Janis also held positions as a Principal Architect and Senior Manager, mentoring other DBAs on best practices in database performance tuning.
LinkedIn: http://www.linkedin.com/in/erinstellato
Contact: http://www.sqlskills.com/blogs/erin
Erin Stellato is a Data Platform MVP and lives outside Cleveland, OH. She has almost 20 years of technology experience and has worked with SQL Server since 2003. Her areas of interest include performance tuning, Query Store, Extended Events, and helping accidental/involuntary DBAs understand how SQL Server works. Erin is an active member of the SQL Server community, has volunteered for PASS at the local and national level, and is a regular speaker at conferences including the PASS Summit, SQLIntersection, and SQLBits. Outside of time with family and friends, she enjoys running, spinning, movies, and all things chocolate.
LinkedIn: http://www.linkedin.com/in/juliesmith0503/
Contact: http://datachix.com
Julie Smith is a Microsoft Data Platform MVP and a BI consultant for Innovative Architects in Atlanta, GA. She#39;s implemented increasingly complex Business Intelligence solutions for over a decade at various organizations. She#39;s also worn many other database “hats” in her career – production DBA and database developer--but data integration and BI are her true passions. Julie holds a BA from the University of South Carolina. She and Audrey Hammonds co-created The Datachix.com blog.
LinkedIn: http://www.linkedin.com/in/thesqlguru
Kevin Boles is a SQL Server expert, working exclusively with the product since v6.5. With over 25 years of database experience and over 45,000 man hours of SQL Server engine experience, he holds many related certifications, is an MCT and was a SQL Server MVP from 2007 to 2012. Kevin has been a very successful independent consultant for over 20 years. His passion is the relational engine, especially designing, building, analyzing and tuning high-performance database applications.
LinkedIn: https://www.linkedin.com/in/briandavis78
Contact: http://blogs.sqlsentry.com
Brian Davis is a Product Integration Engineer at SentryOne and has over 15 years in the IT field in multiple areas including software development, support, user training, and as a DBA. He has been working with SQL Server since 2003 and has hands-on experience with SQL Server 2000 through 2016. Brian is also a PASS Regional Mentor and an active member and leader of the Ohio North SQL Server User Group.
LinkedIn: http://www.linkedin.com/pub/colleen-morrow/2a/95a/651/
Contact: http://colleenmorrow.com
Colleen Morrow is a database professional living in Cleveland, OH who has been working with database systems since 1996. For more than 12 years, she was a Database Administrator at a large law firm where she developed an appreciation for auditing, automation, and performance tuning. Since that time she has worked with clients in the healthcare, manufacturing, software, and distribution/freight delivery industries. Colleen is currently a Senior Consultant at Fortified Data. She is an active member of the Ohio North SQL Server User Group and has presented at many SQLSaturday events as well as PASS Summit 2014 and 2015.
LinkedIn: http://www.linkedin.com/in/russloski
Contact: http://www.sqlmovers.com
Russ Loski is a SQL Server BI Developer based in Dallas-Fort Worth. He current works as a Data Analytics Engineer for Navisite, a remote managed IT services company. Twenty years ago, he began working with SQL Server 6.5. He has since continued to develop applications connected to all of the versions of SQL Server. He has worked with clients in industries from insurance to healthcare, from movie theaters to American football. Russ is a regular speaker at SQLSaturday events, as well as the SQL Server Users Groups in the North Texas region. Russ likes working with data in various shapes.
Contact: http://brentozar.com
Jeremiah Peschka sees the magic in technology. He knows how to do things now, and he also knows how to think about possibilities. Jeremiah likes to imagine new kinds of indexes, new kinds of teams, new kinds of applications. This means that when you need to reinvent something, or get unblocked, you should talk to Jeremiah.
LinkedIn: http://www.linkedin.com/pub/janis-griffin/0/914/aba
Janis Griffin has over 30 years of DBA/database experience including design, development and implementation of many critical database applications. Before coming to Quest Software, Janis primarily worked in the Telecom/Network Industry, working with both real-time network routing databases and OLTP business to business applications. Janis also held positions as a Principal Architect and Senior Manager, mentoring other DBAs on best practices in database performance tuning.
Contact: http://brentozar.com
Jeremiah Peschka sees the magic in technology. He knows how to do things now, and he also knows how to think about possibilities. Jeremiah likes to imagine new kinds of indexes, new kinds of teams, new kinds of applications. This means that when you need to reinvent something, or get unblocked, you should talk to Jeremiah.
LinkedIn: http://www.linkedin.com/in/samsnasr
Contact: http://samnasr.blogspot.com/
Sam Nasr has been a software developer since 1995, focusing mostly on Microsoft technologies. He’s a Sr. Software Engineer with NIS Technologies where he consults and teaches clients about the latest .Net technologies. Sam has achieved multiple certifications from Microsoft (MCSA, MCAD, MCTS, MCT), and is the leader of the Cleveland C#/VB.Net User Group since 2003. In addition, he’s the leader of the .Net Study Group, an author for Visual Studio Magazine, and a Microsoft MVP since 2013. When not coding, Sam loves spending time with his family and friends or volunteering at his local church.
LinkedIn: http://www.linkedin.com/in/samsnasr
Contact: http://samnasr.blogspot.com/
Sam Nasr has been a software developer since 1995, focusing mostly on Microsoft technologies. He’s a Sr. Software Engineer with NIS Technologies where he consults and teaches clients about the latest .Net technologies. Sam has achieved multiple certifications from Microsoft (MCSA, MCAD, MCTS, MCT), and is the leader of the Cleveland C#/VB.Net User Group since 2003. In addition, he’s the leader of the .Net Study Group, an author for Visual Studio Magazine, and a Microsoft MVP since 2013. When not coding, Sam loves spending time with his family and friends or volunteering at his local church.
LinkedIn: http://www.linkedin.com/pub/colleen-morrow/2a/95a/651/
Contact: http://colleenmorrow.com
Colleen Morrow is a database professional living in Cleveland, OH who has been working with database systems since 1996. For more than 12 years, she was a Database Administrator at a large law firm where she developed an appreciation for auditing, automation, and performance tuning. Since that time she has worked with clients in the healthcare, manufacturing, software, and distribution/freight delivery industries. Colleen is currently a Senior Consultant at Fortified Data. She is an active member of the Ohio North SQL Server User Group and has presented at many SQLSaturday events as well as PASS Summit 2014 and 2015.
LinkedIn: http://www.linkedin.com/pub/allen-white-sql-server-mvp/5/784/b08/
Contact: http://dataperfpro.com/blog/
Allen White is a Data Platform consultant. He has been both a developer and an administrator, so he understands both perspectives towards database technology. He loves sharing his experiences and helping people learn how to use SQL Server. Allen has spent over 40 years in IT, using SQL Server since 1992, and has been awarded Microsoft’s MVP Award for the last 13 years. Allen was a PASS Director from 2016 - 2018.
LinkedIn: http://www.linkedin.com/in/thesqlguru
Kevin Boles is a SQL Server expert, working exclusively with the product since v6.5. With over 25 years of database experience and over 45,000 man hours of SQL Server engine experience, he holds many related certifications, is an MCT and was a SQL Server MVP from 2007 to 2012. Kevin has been a very successful independent consultant for over 20 years. His passion is the relational engine, especially designing, building, analyzing and tuning high-performance database applications.
LinkedIn: https://www.linkedin.com/pub/kevin-feasel/7/716/504
Contact: http://www.catallaxyservices.com
Kevin Feasel is a Microsoft Data Platform MVP and CTO at Envizage, where he specializes in data analytics with T-SQL and R, forcing Spark clusters to do his bidding, fighting with Kafka, and pulling rabbits out of hats on demand. He is the lead contributor to Curated SQL (https://curatedsql.com), president of the Triangle Area SQL Server Users Group (https://www.meetup.com/tripass), and author of PolyBase Revealed (https://www.apress.com/us/book/9781484254608). A resident of Durham, North Carolina, he can be found cycling the trails along the triangle whenever the weather's nice enough.
The following is a list of sponsors that helped fund the event.


Word Puzzle
Sentence
Enter a sentence of any length, then press submit to create your puzzle.
Submit


Course at EPIT 2018 Software Verification Spring School in Aussois, France on 7-8 May, 2018
Teaching team: Cătălin Hriţcu, Antoine Delignat-Lavaud, Danel Ahman, and Victor Dumitrescu
The easiest way to try out F* quickly is directly in your browser
using the online editor
that's part of the F* tutorial.
And now we have
an even cooler online editor (experimental).
For people who want to get F* (v<IP_ADDRESS>-alpha1 released on Friday) installed on their machine there are 2 easy options:
In addition, if you're familiar with emacs we recommend getting fstar-mode.
For people who are more motivated, there are even more ways including
building things from sources.
It's all documented in
INSTALL.md.


1Object.keys( O )#
When the
keys function is called with argument O, the following steps are taken:
- Let obj be ToObject(O).
- ReturnIfAbrupt(obj).
- Let nameList be EnumerableOwnProperties(obj,
"key").
- ReturnIfAbrupt(nameList).
- Return CreateArrayFromList(nameList).
If an implementation defines a specific order of enumeration for the for-in statement, the same order must be used for the elements of the array returned in step 5.
NoteThe length property of the keys method is
1.
2Object.values( O )#
When the
values function is called with argument O, the following steps are taken:
- Let obj be ToObject(O).
- ReturnIfAbrupt(obj).
- Let nameList be EnumerableOwnProperties(obj,
"value").
- ReturnIfAbrupt(nameList).
- Return CreateArrayFromList(nameList).
If an implementation defines a specific order of enumeration for the for-in statement, the same order must be used for the elements of the array returned in step 5.
NoteThe length property of the values method is
1.
3Object.entries( O )#
When the
entries function is called with argument O, the following steps are taken:
- Let obj be ToObject(O).
- ReturnIfAbrupt(obj).
- Let nameList be EnumerableOwnProperties(obj,
"key+value").
- ReturnIfAbrupt(nameList).
- Return CreateArrayFromList(nameList).
If an implementation defines a specific order of enumeration for the for-in statement, the same order must be used for the elements of the array returned in step 5.
NoteThe length property of the entries method is
1.
4EnumerableOwnProperties#
When the abstract operation EnumerableOwnProperties is called with Object O and String kind the following steps are taken:
- Assert: Type(O) is Object.
- Let ownKeys be O.[[OwnPropertyKeys]]().
- ReturnIfAbrupt(ownKeys).
- Let properties be a new empty
List.
- Repeat, for each element key of ownKeys in
List order
- If Type(key) is String, then
- Let desc be O.[[GetOwnProperty]](key).
- ReturnIfAbrupt(desc).
- If desc is not
undefined and desc.[[Enumerable]] is
true, then
- If kind is
"key", append key to properties.
- Else,
- Let elementKey be ToString(key).
- Let value be Get(O, key).
- ReturnIfAbrupt(value).
- If kind is
"value", append value to properties.
- Else,
- Assert: kind is
"key+value".
- Let entry be CreateArrayFromList(«key, value»).
- Append entry to properties.
- Order the elements of properties so they are in the same relative order as would be produced by the Iterator that would be returned if the [[Enumerate]] internal method was invoked on O.
- Return properties.
NoteThe order of elements in the returned list is the same as the enumeration order that is used by a for-in statement.
Note: The "
EnumerableOwnNames" section is deleted. Any existing references to
EnumerableOwnNames(x) should be changed to EnumerableOwnProperties(x,
"key")


expect class ApplicationContext
Expects the class to be implemented on iOS and Android. Used by the Android side to pass the Context of the application to the SDK via Injection in the getInstance method of the SDK.
getDeviceId
fun getDeviceId(): String


xPack QEMU Arm v6.2.0-2 released
The xPack QEMU Arm is a standalone cross-platform binary distribution of QEMU, with several extensions for Arm Cortex-M devices.
There are separate binaries for Windows (64-bit), macOS (Intel 64-bit, Apple Silicon 64-bit) and GNU/Linux (Intel 64-bit, Arm 32/64-bit).
Download
The binary files are available from GitHub Releases.
Prerequisites
- GNU/Linux Intel 64-bit: any system with GLIBC 2.27 or higher (like Ubuntu 18 or later, Debian 10 or later, RedHat 8 later, Fedora 29 or later, etc)
- GNU/Linux Arm 32/64-bit: any system with GLIBC 2.27 or higher (like Raspberry Pi OS, Ubuntu 18 or later, Debian 10 or later, RedHat 8 later, Fedora 29 or later, etc)
- Intel Windows 64-bit: Windows 7 with the Universal C Runtime (UCRT), Windows 8, Windows 10
- macOS Intel 64-bit: 10.13 or later; graphical mode available on 10.14 or later
- macOS Apple Silicon 64-bit: 11.6 or later
On GNU/Linux, QEMU requires the X11 libraries to be present. On Debian derived distribution they are already in the system; on RedHat & Arch derived distributions they must be installed explicitly.
Install
The full details of installing the xPack QEMU Arm on various platforms are presented in the separate Install page.
Easy install
The easiest way to install QEMU Arm is with
xpm
by using the binary xPack, available as
@xpack-dev-tools/qemu-arm
from the npmjs.com
registry.
With the xpm
tool available, installing
the latest version of the package and adding it as
a dependency for a project is quite easy:
cd my-project
xpm init # Only at first use.
xpm install @xpack-dev-tools/qemu-arm@latest
ls -l xpacks/.bin
To install this specific version, use:
xpm install<EMAIL_ADDRESS>For xPacks aware tools, like the Eclipse Embedded C/C++ plug-ins, it is also possible to install QEMU Arm globally, in the user home folder.
xpm install --global @xpack-dev-tools/qemu-arm@latest --verbose
Eclipse will automatically
identify binaries installed with
xpm
and provide a convenient method to manage paths.
qemu-system-gnuarmeclipse
. qemu-system-arm
can be used in debug
sessions only when started outside Eclipse.Uninstall
To remove the links from the current project:
cd my-project
xpm uninstall @xpack-dev-tools/qemu-arm
To completely remove the package from the central xPacks store:
xpm uninstall --global @xpack-dev-tools/qemu-arm
Compliance
The xPack QEMU Arm currently is based on the official QEMU, with some changes.
There are two sets of binaries:
-
qemu-system-arm
andqemu-system-aarch64
, based on QEMU version 6.2.0, commit 44f28df2 from Dec 14th, 2021; -
qemu-system-gnuarmeclipse
, based on QEMU version 2.8.0, commit 0737f32 from Dec 20th, 2016; this is end-of-life and will be preserved only for compatibility reasons.
Changes
Compared to the upstream qemu-system-arm
, there are no major changes.
The supported boards and CPUs are:
$ .../qemu-system-arm -machine help
Supported machines are:
akita Sharp SL-C1000 (Akita) PDA (PXA270)
ast2500-evb Aspeed AST2500 EVB (ARM1176)
ast2600-evb Aspeed AST2600 EVB (Cortex-A7)
borzoi Sharp SL-C3100 (Borzoi) PDA (PXA270)
canon-a1100 Canon PowerShot A1100 IS (ARM946)
cheetah Palm Tungsten|E aka. Cheetah PDA (OMAP310)
collie Sharp SL-5500 (Collie) PDA (SA-1110)
connex Gumstix Connex (PXA255)
cubieboard cubietech cubieboard (Cortex-A8)
emcraft-sf2 SmartFusion2 SOM kit from Emcraft (M2S010)
fp5280g2-bmc Inspur FP5280G2 BMC (ARM1176)
fuji-bmc Facebook Fuji BMC (Cortex-A7)
g220a-bmc Bytedance G220A BMC (ARM1176)
highbank Calxeda Highbank (ECX-1000)
imx25-pdk ARM i.MX25 PDK board (ARM926)
integratorcp ARM Integrator/CP (ARM926EJ-S)
kudo-bmc Kudo BMC (Cortex-A9)
kzm ARM KZM Emulation Baseboard (ARM1136)
lm3s6965evb Stellaris LM3S6965EVB (Cortex-M3)
lm3s811evb Stellaris LM3S811EVB (Cortex-M3)
mainstone Mainstone II (PXA27x)
mcimx6ul-evk Freescale i.MX6UL Evaluation Kit (Cortex-A7)
mcimx7d-sabre Freescale i.MX7 DUAL SABRE (Cortex-A7)
microbit BBC micro:bit (Cortex-M0)
midway Calxeda Midway (ECX-2000)
mps2-an385 ARM MPS2 with AN385 FPGA image for Cortex-M3
mps2-an386 ARM MPS2 with AN386 FPGA image for Cortex-M4
mps2-an500 ARM MPS2 with AN500 FPGA image for Cortex-M7
mps2-an505 ARM MPS2 with AN505 FPGA image for Cortex-M33
mps2-an511 ARM MPS2 with AN511 DesignStart FPGA image for Cortex-M3
mps2-an521 ARM MPS2 with AN521 FPGA image for dual Cortex-M33
mps3-an524 ARM MPS3 with AN524 FPGA image for dual Cortex-M33
mps3-an547 ARM MPS3 with AN547 FPGA image for Cortex-M55
musca-a ARM Musca-A board (dual Cortex-M33)
musca-b1 ARM Musca-B1 board (dual Cortex-M33)
musicpal Marvell 88w8618 / MusicPal (ARM926EJ-S)
n800 Nokia N800 tablet aka. RX-34 (OMAP2420)
n810 Nokia N810 tablet aka.
Compared to the master qemu-system-arm
, the changes are major, all
application class Arm
devices were removed and replaced by several Cortex-M devices.
The supported boards are:
xPack 64-bit QEMU v2.8.0 (qemu-system-gnuarmeclipse).
Supported boards:
BluePill BluePill STM32F103C8T6
Maple LeafLab Arduino-style STM32 microcontroller board (r5)
NUCLEO-F072RB ST Nucleo Development Board for STM32 F072 devices
NUCLEO-F103RB ST Nucleo Development Board for STM32 F1 series
NUCLEO-F411RE ST Nucleo Development Board for STM32 F4 series
NetduinoGo Netduino GoBus Development Board with STM32F4
NetduinoPlus2 Netduino Development Board with STM32F4
OLIMEXINO-STM32 Olimex Maple (Arduino-like) Development Board
STM32-E407 Olimex Development Board for STM32F407ZGT6
STM32-H103 Olimex Header Board for STM32F103RBT6
STM32-P103 Olimex Prototype Board for STM32F103RBT6
STM32-P107 Olimex Prototype Board for STM32F107VCT6
STM32F0-Discovery ST Discovery kit for STM32F051 line
STM32F051-Discovery ST Discovery kit for STM32F051 line
STM32F4-Discovery ST Discovery kit for STM32F407/417 lines
STM32F429I-Discovery ST Discovery kit for STM32F429/439 lines
generic Generic Cortex-M board; use -mcu to define the device
Supported MCUs:
STM32F051R8
STM32F103RB
STM32F107VC
STM32F405RG
STM32F407VG
STM32F407VGTx <- new
STM32F407ZG
STM32F411RE
STM32F429ZI
STM32F429ZITx <- new>
Bug fixes
- [#18] the SDL requirement to run the graphical loop on the main thread is enforced on new macOS versions, and the QEMU SDL support requires some more work; revert to Cocoa; this also required running the macOS Intel build on macOS 10.14.
Enhancements
- none
Known problems
- for
qemu-system-gnuarmeclipse
, Ctrl-C does not interrupt the execution if the--nographic
option is used.
Shared libraries
On all platforms the packages are standalone, and expect only the standard runtime to be present on the host.
All dependencies that are build as shared libraries are copied locally
in the libexec
folder (or in the same folder as the executable for Windows).
DT_RPATH
and LD_LIBRARY_PATH
On GNU/Linux the binaries are adjusted to use a relative path:
$ readelf -d library.so | grep runpath
0x000000000000001d (RPATH) Library rpath: [$ORIGIN]
In the GNU ld.so search strategy, the DT_RPATH
has
the highest priority, higher than LD_LIBRARY_PATH
, so if this later one
is set in the environment, it should not interfere with the xPack binaries.
Please note that previous versions, up to mid-2020, used DT_RUNPATH
, which
has a priority lower than LD_LIBRARY_PATH
, and does not tolerate setting
it in the environment.
@rpath
and @loader_path
Similarly, on macOS, the binaries are adjusted with install_name_tool
to use a
relative path.
Documentation
The original documentation is available on-line:
Build
The binaries for all supported platforms (Windows, macOS and GNU/Linux) were built using the xPack Build Box (XBB), a set of build environments based on slightly older distributions, that should be compatible with most recent systems.
The scripts used to build this distribution are in:
distro-info/scripts
For the prerequisites and more details on the build procedure, please see the README-MAINTAINER page.
CI tests
Before publishing, a set of simple tests were performed on an exhaustive set of platforms. The results are available from:
Tests
The binaries were testes on Windows 10 Pro 64-bit, Intel Ubuntu 18 LTS 64-bit, macOS 10.15 (Intel) and 11.6 (Apple Silicon).
For qemu-system-arm
and qemu-system-aarch64
, the tests consist in
simple, non-graphical, semihosting apps. The binaries are borrowed
from µTest++ and are available from the
tests
folder.
.../xpack-qemu-arm-6.2.0-1/bin/qemu-system-arm --version
xPack QEMU emulator version 6.2.0 (v6.2.0-1-xpack-arm)
Copyright (c) 2003-2021 Fabrice Bellard and the QEMU Project developers
mkdir -p ~/Downloads
(cd ~/Downloads; curl -L --fail -o mps2-an386-sample-test.elf \
https://github.com/xpack-dev-tools/qemu-arm-xpack/raw/xpack/tests/mps2-an386-sample-test.elf)
.../xpack-qemu-arm-6.2.0-1/bin/qemu-system-arm \
--machine mps2-an386 \
--kernel ~Downloads/mps2-an386-sample-test.elf \
--nographic \
-d unimp,guest_errors \
--semihosting-config enable=on,target=native,arg=sample-test,arg=one,arg=two
...
For qemu-system-gnuarmeclipse
,
the tests consist in running a simple blinky application
on the graphically emulated STM32F4DISCOVERY board. The binaries were
those generated by
simple Eclipse projects
available in the xPack GNU Arm Embedded GCC project. Use the
arm-f4b-fs-debug-qemu
debug luncher available in the arm-f4b-fs
project.
On platforms where Eclipse is not available, the binaries were tested by manually starting the blinky test on the emulated STM32F4DISCOVERY board.
.../qemu-system-gnuarmeclipse --version
xPack 64-bit QEMU emulator version 2.8.0 (v2.8.0-14-xpack-legacy-dirty)
Copyright (c) 2003-2016 Fabrice Bellard and the QEMU Project developers
mkdir -p ~/Downloads
(cd ~/Downloads; curl -L --fail -o f407-disc-blink-tutorial.elf \
https://github.com/xpack-dev-tools/qemu-eclipse-test-projects/raw/master/f407-disc-blink-tutorial/Debug/f407-disc-blink-tutorial.elf)
.../qemu-system-gnuarmeclipse \
--board STM32F4-Discovery \
-d unimp,guest_errors \
--nographic \
--image ~/Downloads/f407-disc-blink-tutorial.elf \
--semihosting-config enable=on,target=native \
--semihosting-cmdline test 5
...
DISPLAY=:1.0 .../qemu-system-gnuarmeclipse \
--board STM32F4-Discovery \
-d unimp,guest_errors \
--image ~/Downloads/f407-disc-blink-tutorial.elf \
--semihosting-config enable=on,target=native \
--semihosting-cmdline test 5
...
On Raspberry Pi OS 10 (buster) 64-bit the program was able to run in non graphic mode, but did not start in graphic mode due to a missing driver. To be further investigated.
Checksums
The SHA-256 hashes for the files are:
4094a0b94a6372d18db259f0271a9bd78c4366ba0acaf368a41e28d1553f30c9
xpack-qemu-arm-6.2.0-2-darwin-arm64.tar.gz
3f85327921d286cd88325444fe8203efd1ec060966d8892d02484e01fcae7a88
xpack-qemu-arm-6.2.0-2-darwin-x64.tar.gz
c2ad2af2dcdc4fdc6e139a881e480ee10528f6c7731df17c62b50d6ae41cbcb7
xpack-qemu-arm-6.2.0-2-linux-arm.tar.gz
bca775c258865645def4fb4bd6e5308116ca5e8e08c1414224a50bdf9b730adc
xpack-qemu-arm-6.2.0-2-linux-arm64.tar.gz
8a2c62c3d08685d249f80ee7f2cb5dd159f26e41b4da57ecdc561ab2cffb5429
xpack-qemu-arm-6.2.0-2-linux-x64.tar.gz
6f66eaacad1cfcd1871f3ddbcd64f8f829e1c27302aef2ac5f8dc1b1161f6ccc
xpack-qemu-arm-6.2.0-2-win32-x64.zip
Deprecation notices
32-bit support
Support for 32-bit Intel Linux and Intel Windows was dropped in 2022. Support for 32-bit Arm Linux will be preserved for a while, due to the large user base of 32-bit Raspberry Pi systems.
Linux minimum requirements
Support for RedHat 7 was dropped in 2022 and the minimum requirement was raised to GLIBC 2.27, available starting with Ubuntu 18, Debian 10 and RedHat 8.
Download analytics
- GitHub xpack-dev-tools/qemu-arm-xpack
- this release
- all xPack releases
- all GNU MCU Eclipse releases
- individual file counters (grouped per release)
- npmjs.com @xpack-dev-tools/qemu-arm
Credit to Shields IO for the badges and to Somsubhra/github-release-stats for the individual file counters.


{% extends "layout.html" %} {% block content %}
{{post.val().title}}
by {{post.val().author}}
There's nothing here? Click on Databases.