Node Interactive 2015 Recap
Node Interactive 2015 is the Node.js Foundation lead conference.
There are three major tracks of breakout sessions: Server-Side Client-Side Internet of Things
Here are several topics excerpt from mainly the backend track.
Node.js Ecosystem
As of Dec. 2015, there are more than 200,000 Node.js modules exist in NPM, namely, the Node, Package, Manager.
NPM is the largest package manager in the world
After the merge with io.js, the Node release version seems skyrocketed. Luckily, the good thing is Node.js has come up with the LTS version, thus making enterprise adopters more comfortable with this still new technology. While at the same time, it keeps the speed for development and evolving.
Node.js Long Term Support Schedule (as of Dec. 2015)
The Adoption Trend
With Node.js being used in 98% of the Fortune 500 companies regularly, the event will also highlight the maturation of the technology within enterprises.
Capital One, GoDaddy, Intel, NodeSource, NPM and Uber are using Node.js to meet their innovation needs
Startups are leading the way in adding Node.js into their strategy, but in 2013 and 2014 larger incumbents started to transition their stacks with Node.js as a core technology, notable names include PayPal, Condé Nast, and Costa.
Node.js in Production
As the the Node.js technology develops, more and more Big companies put Node.js into production.
Here are some notable examples (as of Dec. 2015):
Paypal: Node.js replaces Java/Spring 2012
Uber: Early adopter, Realtime API, open source: ringpop, tchannel
Netflix: Node.js, restify, React, Docker, AWS EC2 Container
IBM: Top use cases for Node are REST APIs and real time services.
Intel: IoTivity, leader in Internet of Things
Debugging Node.js in Production
Presentation by Yunong Xiao @ Netflix Node Platform
Here are 3 issues in production and their corresponding solution:
- Runtime Performance
- CPU profiling/flame graphs
- Runtime Crashes
- Inspect program state with core dumps
- Memory Leaks
- Analyze objects and references with core dumps
Making Your Node.js Applications Debuggable
Presentation by Patrick Mueller @ NodeSource
Intro
Profiling Node.js mainly referring to performance(CPU) and memory.
- Node Profiling:
- Performance with V8 CPU profiler
- Memory with V8 heap snapshots
Performance
- Understanding performance
- Self time - time to run the function, not including other function calls.
- Total time - time to run the function, including other function calls.
- How to get CPU profiles?
- npm v8-profiler (requires instrumenting your code)
- npm node-inspector
- StrongLoop Arc
- NodeSource N Solid
Memory
- What are v8 heap snapshots?
- JSON file describing every reachable Javascript object in the application, taking snapshots always starts with a garbage collection
- JSON files are … large
- Understanding heap snapshots
- Shallow Size: The memory allocated to store the object itself
- Retained Size: The size of memory that can be freed once an object deleted
Summary
- Profiling performance
- look for width for trace visualization
- scripts: start profile, run load tester, stop profile
- use node/v8 option —no-use-inlining to turn off function inlining
- Profiling memory
- Easiest way to detect memory leak take memory snapshot
- ‘Tag’ objects you think might be leaking with easy to find class
Node.js Performance Optimization
Presentation by Bryce Baril @ NodeSource
Purpose of performance optimization: Task Completion (User experience) & Throughput (Scale)
Proposed workflow for performance optimization:
📝 WORKFLOW 📝
- ❔ Is it fast enough?
- 🔍 Identify the nature of the problem. (🏗 vs 🏭)
- 🔬 Select tools based on the problem.
- 📐 Measure.
- 📍 Identify the location of the problem.
- 👓 Make the slower parts faster.
- 📐 Measure again.
- 🔁 Go back to step 0.
💩 REASONS FOR POOR PERFORMANCE 💩
- Wrong tool for the job;
- Doing unnecessary things;
- Poor algorithm choice;
Useful Resources
If you liked this post, you can share it with your followers or follow me on Twitter!


Music I Like by Genre (Not in any order)
Indie/Pop
- Sunflower by Rex Orange County
- Couch Potato by Jakubi
- Sunkissed by Kahi Dreams
- Watermelon Sugar by Harry Styles
Electronic
- Shelter by Porter Robinson and Madeon
- Pay No Mind by Madeon
- Marble Soda by Shawn Wassabi
- Fireflies by Owl City


'Bayong,' not plastic
by Manny PalmeroEnvironmental groups belonging to the Global Break Free from Plastic Movement hold up ‘bayong’ or woven leaf bags as they stage a protest in front of the head office of Department of Environment and Natural Resources in Quezon City, criticizing the agency’s ‘hypocritical and pro-industry stance’ on plastic pollution.


| copy_tinytex {tinytex} | R Documentation |
The function copy_tinytex()
copies the existing TinyTeX installation
to another directory (e.g., a portable device like a USB stick). The function
use_tinytex()
runs tlmgr path add
to add the copy of TinyTeX
in an existing folder to the PATH
variable of the current system, so
that you can use utilities such as tlmgr
and pdflatex
,
etc.
copy_tinytex( from = tinytex_root(), to = select_dir("Select Destination Directory") ) use_tinytex(from = select_dir("Select TinyTeX Directory"))
from |
The root directory of the TinyTeX installation. For
|
to |
The destination directory where you want to make a copy of TinyTeX.
Like |
You can only copy TinyTeX and use it in the same system, e.g., the Windows version of TinyTeX only works on Windows.


{% extends "base.html" %} {% block content %}
Code Kata is a term coined by Dave Thomas, co-author of the book The Pragmatic Programmer, in a nod to the Japanese concept of kata in the martial arts. A code kata is an exercise in programming which helps a programmer hone their skills through practice and repetition.
The goal of this Kata is to get your mind wired into performance driven development, to reinforce your skills as a user of New Relic.
Of course the code in some areas of this application is intentionally bad, but what fun would this be if everything worked the way it should?
Get the code. Using your github account, fork the newrelic-python-kata repo and then clone it onto your machine.
Create a virtualenv and a heroku app (Use the Heroku toolbelt.)
virtualenv venv source venv/bin/activate pip install -r requirements.txt heroku apps:create git push heroku master
Add New Relic to your Heroku app. The New Relic agent will help you find and solve the performance issues in this application as well as help you see the complete impact of your changes.
heroku addons:add newrelicEdit your 'Procfile' and replace the contents with the following line.
web: newrelic-admin run-program python manage.py run_gunicorn -b "<IP_ADDRESS>:$PORT"
Populate the sample database.
heroku addons:add heroku-postgresql:dev heroku addons:add pgbackups:plus heroku pgbackups:restore DATABASE 'http://newrelic-python-kata.herokuapp.com/sample-data.dump'
Fix the code / Solve as many of the Katas as you can. There are seven distinct Katas in this application that can be torn apart and fixed by using your awesome dev abilities and the deep metrics that New Relic provides.
Let us know how you did, what you liked or disliked, what helped you find problems or what were the challenges, what you like about New Relic and what you don't - we just want to hear from you and see what we can do to get better.


Table of Contents
1 Linear Algebra
Preface
The crucial operation in linear algebra is taking linear combinations of vectors
Ax = b
how to solve it ? three levels:
- Direct solution by forward elimination and back substitution
- Matrix solution using inverse of A: x = A-1b (basis: A has an inverse)
- Vector space solution x = y + z: Particular solution (to Ay = b) plus nullspace solution (to Az = 0)
1.0.1 Structure
numbers -> vectors -> subspaces
1.1 Chapter 1: Introduction to the Vectors
The heart of linear algegra lies in two operations: addition and multiply, which operates on vectors.
- addition: v + w
- multiply: c v, d w
- combinations: c v + d w
for two-dimensional vectors, their combinations fill the whole two-dimensional plane.
1.1.1 Vector additions and linear combinations
DEFINITION The sum of c v + d w is a linear combination of v and w
- What is the picture of all combinations c u ?
- What is the picture of all combinations c u + d v ?
- What is the picture of all combinations c u + d v + e w ?
1.1.2 The dot product of v ⋅ w and the length || v || = \sqrt{*v* \cdot *v*}
DEFINITION The dot product or inner product of v = (v1, v2) and w = (w1, w2) is the number: v ⋅ w = v1*w1 + v2*w2.
Perpendicular Vectors: dot product is zero.
Properties of dot product:
- commutative law: v ⋅ w = w ⋅ v
- distributive law: a ⋅ (b + c) = a ⋅ b + a ⋅ c
- bilinear: a ⋅ (γ b + c) = γ a ⋅ b + a ⋅ c
- scalar multiplication (c1 a) ⋅ (c2 b) = c1 c2 a ⋅ b
- orthogonal: a ⋅ b = 0
Caution:
- Not associative: a \codt b ⋅ c is not right (think about it)
- No cancellation: a ⋅ b = a ⋅ c not ⇒ b = c
Length And unit Vectors
DEFINITION The length of a vector a is \sqrt{*a* \cdot *a*}
DEFINITION A unit vector u is a vector whose length is one, thus u ⋅ u = 1
For any vector v, v / || v || is a unit vector(v is not a zero vector)
Unit vectors u and U at angle θ have u ⋅ U = cosθ. Certainly | u ⋅ U | ≤ 1.

SCHWARZ INEQUALITY: | w ⋅ v | ≤ || w || * || v ||
TRIANGLE INEQUALITY: || w + v || ≤ || w || + || v ||
Besides
Cauchyâ€“Schwarz inequality:
Background: The inequality for sums was published by Augustin-Louis Cauchy (1821), while the corresponding inequality for integrals was first proved by Viktor Bunyakovsky (1859). The modern proof of the integral inequality was given by Hermann Amandus Schwarz (1888)
For all vectors u and v of an inner product space it is true that: || u ⋅ v ||2 ≤ || u ||2 * || v ||2.
Application: Analysis, Geometry, Probability theory
1.1.3 Matrices A, linear equations Ax = b, solutins x = A-1b
Combinations: c[1, -1, 0]T + d[0, 1, -1]T + e[0, 0, 1]T = [c, d-c, e-d]T. Now we transform it to matrice, vectors u, v and w go into the columns of matrix A: (c, d, e) are the components of vector x.(think about it, why (c, d, e) are components of a vector x). See the picture below:
Linear Equations
One more change in viewpoint is crucial, Now we think of b as known and we look for x.
Old question: Compute the linear combination x1 u + x2 v + x3 w to find b. New question: Which combination of u, v, w produces a particular vector b?
The Inverse Matrix
The sum matrix S in equation (7) is the inverse of the difference matrix A.
Cyclic Differences
This matrix C is not triangular. It is not so simple to solve for x when we are given h. Actually it is impossible to find the solution to ex = b, because the three equations either have infinitely many solutions or else no solution.
Independence and Dependence
Independence: w is not in the plane of u and v. Dependence: w* is in the plane of u and v.


--- layout: post status: publish published: true title: Download Faster Than IDM in linux author: display_name: vishvendra login: vishvendra email<EMAIL_ADDRESS>url: '' author_login: vishvendra author_email<EMAIL_ADDRESS>wordpress_id: 441 wordpress_url: https://vishvendrasingh.com/?p=441 date: '2017-01-24 12:25:28 +0530' date_gmt: '2017-01-24 12:25:28 +0530' categories: - Linux tags: [] comments: [] ---
Here 16 is the no of connections. aria2c is multi protocol and you can use this to download torrent also with magnetic links directly
aria2c -x 16 http://example.com/filename.mp4


RulePad
RulePad is a part of Active Documentation project.
Good documentation offers the promise of enabling developers to easily understand design decisions.
Unfortunately, in practice, design documents are often rarely updated, becoming inaccurate, incomplete, and untrustworthy. A better solution is to enable developers to write down design rules which may be checked against code for consistency. But existing rule checkers require learning specialized query languages or program analysis frameworks, offering a barrier to writing project-specific rules.
We introduce two new authoring techniques for design rules: snippet-based authoring and semi-natural-language authoring.
In snippet-based authoring,
developers specify characteristics of elements to match by writing partial code snippets.
In semi-natural language authoring,
a textual representation offers a representation for understanding design rules and resolving ambiguities,
which is bidirectionally synchronized.
We implemented these approaches in RulePad.
Our paper is published and presented in ESEC/FSE 2020.
2-Minute Teaser
Full Presentation
Tool Demo
RulePad is implemented as a plugin for IntelliJ IDE. The following demo is a partial implementation of RulePad. Some of RulePad features require IDE APIs, and thus is not available in the online Demo. You can checkout the complete behavior of RulePad here.


This is a simple javascript form. Error messages use alert, so try not to make too many. If only we could use twitter bootstrap.
Data on this page is not recorded.


Back
AJAX settings via jQuery object
Overview
Slick Design
and Limitless Customization
Some of it's key features
Documentation
10+ Preset themes
Error Example
AJAX settings via HTML5 data attributes
Overview
Slick Design
and Limitless Customization
Some of it's key features
Documentation
10+ Preset themes
Error Example
NOTE: Some browsers like Chrome and Safari has a restriction on using ajax with local resources. It will throw an error. To solve this, try Use firefox or upload your data to a temporary web server.


operator fun get(ifield: InstructionField): Int
Returns the value of the given instruction field for this instruction.
ifield - the instruction field to get
ifield
Return the value of the given instruction field


Stellar Price Analysis: XLM Rises To $0.068, Can It Go Higher?
by Yaz SheikhStellar saw a sharp increase of around 8% over the past 24 hours and it currently trades at $0.068. The cryptocurrency went on a nice run in the second half of October after increasing by a total of 17% over the last 30 days.
Stellar is now the tenth-largest cryptocurrency with a market cap of $1.39 billion.
Looking at the XLM/USD 1-Day Chart:
- XLM suffered over the past 3 months after dropping by a total of 63% from June’s high to September’s support at $0.053. XLM rebounded here and started to ascend during October. The cryptocurrency is now facing resistance at the 100-days EMA at $0.070 and at the bearish .236 at $0.07297.
- From above: The nearest level of resistance lies at the aforementioned levels at $0.070 and $0.07297. Above this, resistance is expected at $0.075, $0.077 (1.272 Fib Extension), and $0.0799 (1.414 Fib Extension). Above this, strong resistance is at $0.085 which is provided by the bearish .382 Fib Retracement and bolstered by the 200-days EMA.
- From below: The nearest level of support lies at $0.065 and $0.06. Beneath this, support is expected at $0.0578, $0.055, and $0.053.
- The trading volume has surged over the past two days.
- The RSI has recently penetrated above the 50 level to show that the bulls are in control over the market momentum. However, the Stochastic RSI has recently produced a bearish crossover signal which could send the market downward.
Looking at the XLM/BTC 1-Day Chart:
- Against Bitcoin, XLM fell from June through September until support was found at the 560 SAT level. It managed to rebound there but now it’s facing a by very strong resistance at the 818 SAT level. So far, the cryptocurrency hasn’t been able to break above during both September and October.
- From above: The nearest level of resistance lies at 818 SAT which is provided by the 100-days EMA. Above this, resistance is found at 854, 900 (bearish .236 Fib Retracement), 922 SAT (1.272 Fib Extension), 1041 SAT (1.414 Fib Extension), and 1100 SAT (bearish .382 Fib Retracement).
- From below: The nearest level of support lies at 684 SAT. Beneath this, support lies at 650 SAT, 600 SAT, and 560 SAT.
- The trading volume has surged during today’s trading session.
- The RSI has recently crept above the 50 level to show that the bulls have taken control over the market momentum. Furthermore, the Stochastic RSI has recently produced a bullish crossover signal in oversold conditions which is a strong buying signal.
Click here to start trading on BitMEX exchange and receive 10% discount on fees for 6 months.
Disclaimer: Information found on CryptoPotato is those of writers quoted. It does not represent the opinions of CryptoPotato on whether to buy, sell, or hold any investments. You are advised to conduct your own research before making any investment decisions. Use provided information at your own risk. See Disclaimer for more information.
Cryptocurrency charts by TradingView.
Technical analysis tools by Coinigy.


DroneKit-Python 2.0 has undergone a significant architectural evolution when compared to version 1.x (the library changed from a MAVProxy extension to a standalone Python module). The API itself remains similar, with the most important difference being that you now need to specify the vehicle target address inside the script.
The sections below outline the main migration areas.
Note
DroneKit-Python version 1.5 has now been superseded (see these links for legacy documentation and examples).
DKPY 2.0 is now installed from pip on all platforms - see Installing DroneKit for more information.
Installation is generally simpler than on DK 1.x because there are far fewer dependencies (both MAVProxy and numpy are no longer needed).
Note
DroneKit-Python 2.0 apps are run from an ordinary Python command prompt. For example:
some_python_script.py # or `python some_python_script.py`
Note
This contrasts with DKPY 1.x scripts, which were run from within MAVProxy using the command:
api start some_python_script.py
This section outlines the changes you will need to make to your DroneKit-Python scripts.
You must specify the target vehicle address in your script (in DKPY 1.x this was done when you launched MAVProxy).
The code fragment below shows how you import the connect()
method and use it to return a
connected Vehicle
object. The address string passed to connect()
takes the same
values as were passed to MAVProxy when setting up a connection in DKPY 1.x (in this case, a SITL instance running on the same computer).
from dronekit import connect
# Connect to the Vehicle (in this case a UDP endpoint)
vehicle = connect('<IP_ADDRESS>:14550', wait_ready=True)
Note
The wait_ready=True
parameter ensures that connect()
won’t return until
Vehicle.parameters
and most other default attributes have been
populated with values from the vehicle. Check out Vehicle.wait_ready()
for more
information (this method is used by the connect()
implementation).
connect()
also has arguments for setting the baud rate,
returning your own custom vehicle classes and setting the length of the connection timeout.
After connecting, the returned vehicle
can be used in exactly the same way as in DKPY 1.x.
Note
The above code replaces DKPY 1.x code to get the Vehicle (similar to the example below):
# Get an instance of the API endpoint
api = local_connect()
# Get the connected vehicle (currently only one vehicle can be returned).
vehicle = api.get_vehicles()[0]
DroneKit no longer runs in MAVProxy so scripts don’t need to monitor and act on external thread shutdown commands.
Remove code that checks the api.exit
status (note that the api.exit
call below is commented out).
while not vehicle.armed # and not api.exit:
print " Waiting for arming..."
time.sleep(1)
Note
In fact you should delete all references to APIConnection
class and its methods (get_vehicles()
, exit()
and stop()
).
Examples that might possibly have outstanding messages should call Vehicle.close()
before exiting to ensure that all messages have flushed before the script completes:
# About to exit script
vehicle.close()
Remove any code that uses the local_arguments
array to get script-local command line arguments (via MAVProxy).
From DKPY 2.0 command line arguments are passed to sys.argv
as with any other script. The examples use the
argparse module for argument parsing, but you can
use whatever method you like.
Note
In DKPY 1.x the script’s sys.argv
values were the values passed to MAVProxy when it was
started. To access arguments passed to the script from MAVProxy you used the local_arguments
array.
For example if you started a script as shown below:
api start my_script.py 101
Then you would read the integer in your code using
my_argument = int(local_arguments[0])
DroneKit-Python v1.x passed a global property load_path
to any executed file containing the
directory in which the script was running. This is no longer needed in version 2 and has been removed.
Instead, use normal Python methods for getting file system information:
import os.path
full_directory_path_of_current_script = os.path.dirname(os.path.abspath(__file__))
DroneKit-Python v1.x had a Vehicle.location
attribute which provided latitude and longitude information in the
global frame, and altitude either relative to sea-level or the home location (depending on the value of its is_relative
member).
DKPY2.0 uses and attribute with the same name to provide location in global, global-relative and local (NED) frames:
print "Global Location: %s" % vehicle.location.global_frame
print "Global Location (relative altitude): %s" % vehicle.location.global_relative_frame
print "Local Location: %s" % vehicle.location.local_frame
For more information see: Vehicle.location
,
Vehicle.location.global_frame
,
Vehicle.location.global_relative_frame
,
Vehicle.location.local_frame
, and Vehicle State and Settings.
DroneKit-Python v1.x provided guided mode takeoff and movement methods Vehicle.commands.takeoff()
and Vehicle.commands.goto()
.
DKPY2.0 instead provides Vehicle.simple_takeoff
and
Vehicle.simple_goto
. These are the same as the old methods
except that simple_goto
allows you to optionally set the default target groundspeed and airspeed.
Vehicle.airspeed
and
Vehicle.groundspeed
are now settable values. Call these to
set the default target speed used when moving with Vehicle.simple_goto
(or other position-based movement commands).
DroneKit-Python 1.x code retrieved the home location from the first element in Vehicle.commands
.
This code must be replaced with the DroneKit-Python 2.x Vehicle.home_location
attribute.
Tip
Even though the home location is no longer returned as the first waypoint in Vehicle.commands
,
you will still need to download the commands in order to populate the value of
Vehicle.home_location
.
The API for working with missions has been improved and made significantly more robust.
One of the major changes is that the Vehicle.commands
list no
longer includes the home location waypoint in the 0th
index. Another change is that we now wait for command download to complete using
Vehicle.commands.wait_ready()
.
All the known bugs have been fixed. It is now much easier to download, clear, and add items to the mission because there is no need to work around race conditions and other issues with the API.
For more information see Missions (AUTO Mode).
The DroneKit-Python 1.x observer function vehicle.add_attribute_observer
has been replaced by
Vehicle.add_attribute_listener()
or
Vehicle.on_attribute()
in DKYP2.x, and Vehicle.remove_attribute_observer
has been repaced by remove_attribute_listener()
.
The main difference is that the callback function now takes three arguments (the vehicle object, attribute name, attribute value) rather than just the attribute name. This allows you to more easily write callbacks that support attribute-specific and vehicle-specific handling and means that you can get the new value from the callback attribute rather than by re-querying the vehicle.
Note
The difference between Vehicle.add_attribute_listener()
and
Vehicle.on_attribute()
is that attribute listeners added using
Vehicle.on_attribute()
cannot be removed (while on_attribute()
has a more elegant syntax).
A few attributes have been modified so that they only notify when the value changes:
Vehicle.system_status
,
Vehicle.armed
, and
Vehicle.mode
. Users no longer need to add caching code
for these attributes in their listeners.
Attributes that provide “streams” of information (i.e. sensor output) remain unchanged.
Note
If you’re creating your own attributes this caching is trivially
provided using the cache=True
argument to
Vehicle.notify_attribute_listeners()
.
See Observing attribute changes for more information.
In DKPY2 you can now observe parameters in order to
be notified of changes, and also iterate
Vehicle.parameters
to get a list of off the supported
values in the connected vehicle.
In addition, the code to download parameters and keep information in sync with the vehicle is now a lot more robust.
DroneKit-Python 1.x used Vehicle.set_mavlink_callback()
and Vehicle.unset_mavlink_callback
to set/unset a callback function that was invoked for every single mavlink message.
In DKPY2 this has been replaced by the Vehicle.on_message()
decorator, which allows you to specify a callback function that will be invoked for a single message
(or all messages, by specifying the message name as the wildcard string ‘*
’).
Tip
Vehicle.on_message()
is used in core DroneKit code for
message capture and to create Vehicle
attributes.
The API also adds Vehicle.add_message_listener()
and Vehicle.remove_message_listener()
.
These can be used instead of Vehicle.on_message()
when you need to be
able to remove an added listener. Typically you won’t need to!
See MAVLink Messages for more information.
In addition to the home_location,
a few more attributes have been added, including:
Vehicle.system_status
,
Vehicle.heading
,
Vehicle.mount_status
,
Vehicle.ekf_ok
,
Vehicle.is_armable
,
Vehicle.last_heartbeat
.
Warning
Channel overrides (a.k.a “RC overrides”) are highly discommended (they are primarily implemented for simulating user input and when implementing certain types of joystick control).
DKPY v2 replaces the vehicle.channel_readback
attribute with
Vehicle.channels
(and the Channels
class) and the vehicle.channel_override
attribute with
Vehicle.channels.overrides
(and the ChannelsOverrides
class).
Documentation and example code for how to use the new API are provided in Example: Channels and Channel Overrides.
DroneKit-Python 1.x scripts were run in the context of a MAVProxy. This made them difficult to debug because you had to instrument your code in order to launch the debugger, and debug messages were interleaved with MAVProxy output.
Debugging on DroneKit-Python 2.x is much easier. Apps are now just standalone scripts, and can be debugged using standard Python methods (including the debugger/IDE of your choice).


Well having helped a well known ethnobotanical vendor set up a new website on Iboga, he invited me to a kambo frog medicine ceremony. This was an opportunity I was unable to pass up.  Very random and very vivid…certainly not normal frog behaviour…
Skip forward a few weeks to the weekend of the ceremony. I travel down to the place. It just so happens the owner of a health food website I’ve known of for ages is our host…I had recently encountered her Iboga blog online. She is a very warm, cool person, and immediately on arrival, I feel very welcome at this place, a kind of community. I am sober on the Saturday eve, due to having my kambo ceremony on the Sunday. I have some great chats to people there. A raw food chef, a girl studying her masters degree in Ireland, some shamans that work with iboga and ayahuasca…and many others…an eclectic and effervescent gathering of people, I feel very welcome as soon as I arrive.
There had been a delay and VISA problems, preventing the main guy running the kambo sessions from coming. However the guy he works with was in London and could make it. This guy, with his helpers and the shaman hosting the gathering all arrived late on the Saturday night, as did the well known ethnobotanical vendor, and we chatted as the guys prepared the frog medicine. The guy running the frog medicine sessions was an extremely warm, loving guy who just emanated positive vibes. I felt immediately comfortable with him. He worked with ayahuasca and the Santo Daime church as well. He explained in detail about kambo, about its mythology, and its effects, and impact on his, and his helpers lives…all very positive stuff.
Apparently the gift of kambo was received during an ayahuasca vision a shaman was having, where the arms of the great spirit showed him the Kambo frog (Phyllomedusa bicolour), and that frog in particular…there being many, many different species of tree frogs in the Amazon.
He then sang some kambo medicine hymns, which opened with “The Kambo frog will kiss you…” My hair stood on end…this was exactly what happened in my dream! This was very positive though, it felt very right for me to be there, then, at that corner of time and space in the world.
A quick note on kambo…the frog is not harmed in any way during the extraction, only mildly stressed for a very short amount of time…it is thought of as extremely bad form to harm the frog in any way, and will bring wrathful intervention from the animal spirits. Harvesting kambo is arguably much more sustainable than harvesting and destroying ayahuasca vines.
The guy prepared the frog secretions for each person, and while this is going on, we were instructed to drink 2 litres or more of water down, to produce a deep cleansing purge. He then burned us, seven times, on the arm for men, and on the leg for women. It is only momentarily uncomfortable, then stings mildly.
Many people went on Saturday, until 7:30 in the morning, and there was much vomiting and groaning during this time. Sunday was my day. After a little sleep, I woke up and fasted before hand. However it turns out we were able to drink some Brazilian Santo Daime ayahuasca during this time. I have never drunk ayahuasca during the day before, and I heard the Indians believed it was very bad to do so (similar to the Mazatec with mushrooms). We all had 3 glasses of this ayahuasca…the mildest tasting, least fowl I’ve ever had…and it was such a positive experience. The brew was almost all caapi I think, with maybe a touch of chakruna, but it was an important experience for me.
Before this I had been seeking spectacular visions of the ayahuasca serpent I think…but I don’t need visuals or visions to be embraced by the essence of the plant…it was a very warm, peaceful, nurturing, nourishing experience. I actually caught up on sleep by closing my eyes and going into trance, and felt much more awake after the ayauasca. It was a beautiful day as well, and I was sitting next to my ethnobotanical friend, and he remarked on how beautiful everyone looked from the ayahuasca. And it was true…the energy unique to everyone and what made them special was visible.
Then came the evening, and the time of the kambo ceremony. I was in no rush, content with the ayahuasca afterglow, not having encountered ayahuasca for some time. People went before me, and some people left, and some new people arrived. I was a bit apprehensive I must say…several people had passed out and collapsed as a result of the kambo, and almost all sounded like they were in agony. However this amazing girl went before me, and just laughed and smiled, then she would purge, and carried on laughing and smiling! She had such a beautiful, positive energy, it was great for me she went before…apprehension was replaced with respect for the medicine.
 I felt the kambo within seconds. I tried my best to smile during the experience. I didn’t want or hope to out do the girl before me, but I loved the way she had handled herself, in a way where full grown men had crumpled in groaning, nauseated agony. A heat rose to my head, and my heart rate went up. It wasn’t unpleasant really, just odd.
This feeling grew in intensity…I focused on breathing, and this was a great anchor. I felt electricity surging into my hands…my gut was being twisted…the guide sang to me and shook his rattle. I purged…deeply and cleanly…repeatedly, all the water I had drunk.
My eyes were glued shut, my throat was a bit swollen, and my gut was still being twisted. I didn’t have any visions, as such, although I hear these may arise the more one works with kambo. I finally purged again. This time it came deep from within me…the ayahuasca from earlier in the day, and stomach bile…it felt like the kambo had gently squeezed all the impurities out of my liver and I was purging them.
There was no trace of fear or anxiety during the experience. The experience, while very intense, was not as intense as I expected after observing others go through it. I had given myself over to the kambo and trusted in its power. The main period of intensity lasted only ten minutes. Then I could open my eyes, and my swollen throat began to recede. It was amazing being supported by all these people, all willing you on, while you are so vulnerable.
I had some good chats with people when I was back, and connected with some more great people. One guy ran an ethnobotanical company here in the UK, and two Irish girls had had two kambo ceremonies, one on each day.
Later in the night, we experienced these eye drops, and extract of a plant used by the Matses I think…it was painful, but only for a minute or two.
Later, we slept, and on waking, I realised how good I felt. Clear, strong. We moved furniture around and packed up and cleaned up. I said my goodbyes to everyone and headed down to Brighton with two of the kambo helpers and the shaman hosting it. He gave myself and one of the kambo guys a card reading…not that I go in for some of these things…but it was weird. We both picked the same card…Temple Gates…and everything that was said had been on my mind, and was true to my life, since the Iboga ceremony. The other guy had also encountered Iboga in June, around the same time as me…and he will be meeting it for the second time this coming weekend, the same as me…strange coincidence maybe.
I was quite emotional on saying my final goodbyes in Brighton and leaving on the train, and I don’t usually get emotional like this. I feel so lucky to have experienced that couple of days, with those people…it’s not something I will ever forget.
I can feel the kambo now still half a week later, and I have only had the one ceremony. Apparently it gets deeper with future sessions. Likely the ayahuasca is contributing to the afterglow, but I feel incredible clarity, and power in my body. The days following I had less desire for sleep or food, likely why the Matses use it prior to going hunting. I feel deeply cleansed by the experience, and despite its intensity, and compete lack of recreational qualities…I would very much like to meet it again. It’s strange to me, as part of my mind thinks a venom is a defensive poison, best avoided at all costs. Yet the state of mind and body I feel now, I can only conclude that Kambo is a powerful medicine.
Viva la kambo!! :)
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.


THE NINTH GATE RATING: 8 /10 --> Great movie
For more reviews and movie trailers, visit http://www.joblo.com/
Another devil movie?!? Well, not really. Sure this film is centered around a man's search for ancient satanic books, but unlike STIGMATA which took the MTV route or END OF DAYS, which took Arnie and dove head-first into thrill mode, this film relies entirely on its mood, its haunting score, its carefully laid out clues and its leading man to keep your interest.
PLOT: An unscrupulous book appraiser is hired by an eccentric collector to find and authenticate the two other copies of the "Book of the Nine Gates", a tome which apparently holds the key to conjuring up the devil. It isn't long before the book sleuth finds himself caught up in a mysterious game of cat and mouse.
CRITIQUE: Creepy, atmospheric, slow-moving mystery which drew me in with its awesome opening credit sequence, kept me interested with its dark, moody look and sound, and stapled my final approval with an unpredictable resolution worthy of a second trip to the theatres. But let's talk real turkey here...Johnny Depp pots yet another great role and takes full advantage of his ever-expanding talent to present us with yet another unique and engaging performance. This man is totally on top of his game right now (besides being a great-looking individual!) and seriously has me looking forward to any of his future roles. Harumph...but back to the review. This movie is definitely not for your typical thrill-a-minute popcorn crowd. No way! In fact, its mandate doesn't really include thrills as much as it does the creation of feelings of uneasiness. I don't know if it was just me, the film's brooding cinematography, its eerily seductive soundtrack or the general Euro-feel of the entire movie, but this one definitely had me by the balls the whole way through.
Of course, it's really more of a mystery film than anything else. A thinking man's (or woman's) movie, if you will. No easy answers. No wham-bam-thank-you ma'ams. Just a lot of subtle hints here and there, something said, something shown, a person seen before...definitely a film which asks its audience to pay attention and appreciate its drawn out nature. And drawn out it is. The one thing I would have liked was if they had cut it down a little, it felt like it ran on a little near the end. But then again, once the final resolution revealed itself, I can't say that I held much else against the film. Having said that, it is to note that the ending is actually quite vague and surely in need of further discussion or re-examination in order to fully appreciate its meaning. I mixed and matched some of my ideas with that of my friend, and within a few minutes, we had already uncovered several interesting theories to complete the puzzle. Ironically, it is the film's ambiguity that left me further intrigued to watch it all over again. Of course, I won't deny that its unclear ending, peculiar pace and sheer length won't easily turn many people off, because I am sure that they will, but for me personally, the film worked on several levels, with the most important one being that of entertainment.
I really liked this film. Johnny Depp is always interesting to watch, the plot has basically been seen before but not with all of its subtleties, the score is Hitchcockian and flawlessly intertwined with the film's dark, stylish look and best of all, the ending keeps your brain working even after the final reel clicks the end. Don't expect action, don't expect many thrills, don't expect Arnie with a machine gun. This is a simple mystery film mangled in the supernatural with zero special effects and a lot of depth. Interested?
Review Date: March 7, 2000 Director: Roman Polanski Writers: Roman Polanski, John Brownjohn and Enrique Urbizu Producer: Roman Polanski Actors: Johnny Depp as Dean Corso Lena Olin as Liana Telfer Frank Langella as Boris Balkan Emmanuelle Seigner as The Girl Genre: Thriller Year of Release: 2000 ---------------------------------- JoBlo's Movie Emporium http://www.joblo.com/ ---------------------------------- (c) 2000 Berge Garabedian
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


--- layout: default-data title: Groups Overview custom_css: default breadcrumb: ATT&CK® Groups Overview ---
By mapping the various Engagement Activities to ATT&CK, we can ensure that each activity in Engage is driven by observed adversary behavior. In adversary engagement operations it can be tempting to try to anticipate the adversary actions. However, without extensive understanding of the specific threat, this line of thinking can lead the defender to make incorrect or ineffective decisions. By mapping to ATT&CK, we can ensure that our chosen engagement activities are appropriate for the target adversary.
The following table provides a list of ATT&CK Groups with Mapped Enterprise ATT&CK Techniques. Each one links to a details page to show the ATT&CK Mapping entries that apply to that specific group.
| ATT&CK® Group | Description | {%- for group in site.data.attack_groups -%} {%- assign displayed = 0-%} {%- for row in site.data.attack_mapping -%} {%- for tech in group.techniques -%} {%- if row.attack_technique == tech.technique_name -%} {%- if displayed == 0 -%}
|---|---|
| {{ group.name }} | {{ group.description }} |


The formulas for converting sRGB colors to linear, and the reverse, are usually given as follows:
|
|
The definition uses two different functions – a straight line and an exponential curve – glued together at a certain “cutoff point”. The implication is that these functions (the ones in the sRGB to Linear definition) intersect at the point:
| (0.0404500000000000, 0.00313080000000000) |
If we take a close look at the function, though, we can see this intersection point is not exact, so the formula has a slight discontinuity:
| sRGB | Linear |
|---|---|
| 0.0404500000000000 | 0.00313080495356037 |
| 0.0404500000000001 | 0.00313080728306769 |
If we extend the functions, we see that they actually intersect at two points:
The intersection points are approximately:
| (0.0381547987133173, 0.00295315779514840) |
| (0.0404482362771082, 0.00313066844250063) |
If we use either of these two points as the cutoff point, there will be no discontinuity at all. It’s apparent that the sRGB inventors selected the second of these points, and rounded its value to 4 significant digits to get 0.04045. They then used that rounded sRGB value to recalculate the Linear value, and got 0.00313080. I don’t know why their Linear value has more significant digits (5 or 6) than their sRGB value (4).
I guess that if you’re a perfectionist, and want no discontinuity at all, you can tweak the formulas like this:
|
|
It doesn’t make any practical difference. The two functions are extremely close together in this region, so the precise cutoff point is almost irrelevant.
Some references give a formula with a different cutoff point:
| sRGB to Linear | |
|---|---|
| Condition | Value |
| 0 ≤ S ≤ 0.03928 | S/12.92 |
| 0.03928 < S ≤ 1 | ((S+0.055)/1.055)2.4 |
Evidently, this came from the fact that the slope of 1/12.92 is actually a rounded version of a more theoretically correct slope of about 1/12.92321. A cutoff of 0.03928 is what you would arrive at if you used that slope.
However, the sRGB standard defines 12.92 as the exact value to use. So I don’t think it would be correct to use 12.92321 in sRGB formulas.
In any case, there’s certainly no reason to use 0.03928 together with 12.92. That would be half-baked, and it leads to a discontinuity that is possibly big enough to be significant:
| sRGB | Linear |
|---|---|
| 0.0392800000000000 | 0.00304024767801858 |
| 0.0392800000000001 | 0.00303949248622587 |


#plottertwitter, #generative
➡
➡
➡
Please 🐻 with me. This will be code heavy.
Full code
example is link in the slide at the end.
import List.Extra exposing (initialize, andThen)
makeGrid : Int -> Int -> List ( Float, Float )
makeGrid m n =
initialize m toFloat
|> andThen (\x -> initialize n toFloat
|> andThen (\y -> [ ( x, y ) ]))
Recipe taken from Elm-Packages : List.Extra
> initialize 2 toFloat
[0,1] : List Float
> makeGrid 2 2
[(0,0),(0,1),(1,0),(1,1)] : List ( Float, Float )
import Svg exposing (Svg)
import Svg.Attributes as Attributes
line : Float -> Float -> Float -> Float -> Svg msg
line x1 y1 x2 y2 =
Svg.line
[ Attributes.x1 <| toString x1
, Attributes.y1 <| toString y1
, Attributes.x2 <| toString x2
, Attributes.y2 <| toString y2
]
[]
type Model
= Setup ...
| Model ... (...)
type Msg
= Generate
| Draw (...)
init = update Generate (Setup ...)
update msg model =
case ( msg, model ) of
( Generate, Setup ... ) ->
-- | Tell Elm to populate random numbers into Draw
( Draw, Setup ... ) ->
-- | Create our Model for rendering
view (Model ...) =
List.mapN drawFunction initialShape randomValues
type Model
= Setup Int Int -- | Grid (m x n) in size
| Model Int Int (List Float) -- | Mix in random values
type Msg
= Generate
| Draw (List Float)
init : ( Model, Cmd Msg )
init =
update Generate (Setup 16 16)
import Random exposing (Generator)
random : Generator Float
random =
Random.float -0.5 0.5 -- | Generate a value between -0.5 and 0.5
randomList : Int -> Generator (List Float)
randomList n =
Random.list n random
update : Msg -> Model -> ( Model, Cmd Msg ) -- | Calls `view` each time
update msg model =
case ( msg, model ) of
( Generate, Setup m n ) ) ->
( model, Random.generate Draw <| randomList (m * n) )
( Draw rs, Setup m n ) ->
( Model m n rs, Cmd.none )
_ ->
( model, Cmd.none )
import Svg.Attributes exposing (transform)
view : Model -> Svg Msg
view (Model m n rs) =
let
flip r = if r > 0 then 0 else 90
in
List.map3
(\( dx, dy ) (( x1, y1 ), ( x2, y2 )) r ->
Svg.g
[ transform <|
(" translate(" ++ toString dx ++ "," ++ toString dy ++ ") ")
++ " rotate(" ++ toString (flip r) ++ ") "
]
[ line x1 y1 x2 y2 ]
)
(makeGrid m n)
(List.repeat (m * n) ( ( -0.5, -0.5 ), ( 0.5, 0.5 ) ))
rs
Creating the illusion of order out of pure randomness.
type Model =
Setup Int | Model Int Curtain
type Curtain =
Curtain (List (List Float)) (List (List Float))
view : Model -> Svg Msg
view (Model n (Curtain a b)) =
Svg.g
[]
-- | creates `List (List (Float, Float))` with 100 segments each.
(initialiseLines 100
-- | Add random and shepherded random values to each list of points
|> List.map2 (map2First (+)) a
|> List.map2 (map2First (+)) (accumulateList a)
|> List.map2 (map2First (+)) b
|> List.map2 (map2Second (+)) (accumulateList b)
-- | Draw each line
|> List.map lines
)
Trivia: it was originally created to simulate plants in nature.
Exmaple taken from The Algorithm Beauty of Plants
Starting point: (0, 0), angle: 0° (->)
Starting state: DRDRDRD
Starting state: DRDRDRD
Rule: D -> DDRDLDRDRDD
type alias Rule a =
a -> List a
apply : Rule a -> List a -> List a
apply rule states =
List.concatMap (\s -> rule s) states
type State
= D
| S
| L
| R
turtle : List State -> ( Float, Float ) -> Float -> List Segment
turtle states point angle =
let
move ( x, y ) a =
( x + cos (degrees a), y + sin (degrees a) )
next ( p, a ) state =
case state of
D -> ( ( move p a, a ), [ PathD.L (move p a) ] )
S -> ( ( move p a, a ), [ PathD.M (move p a) ] )
L -> ( ( p, a - 90 ), [] )
R -> ( ( p, a + 90 ), [] )
in
List.concat (Tuple.second <| mapAccuml next ( point, angle ) states)
Because Elm doesn't (yet) have:
We use port — Elm's foreign function interface to Javascript.
port print : String -> Cmd msg
app.ports.print.subscribe( () => {
const node = document.getElementById('frame');
const payload = { svg: node.outerHTML };
http('POST', api(port, '/print'), payload)
.then(console.log)
.catch(console.error);
});


{% raw %}
The official URL for this profile is:
https://paciowg.github.io/functional-status-ig//StructureDefinition/pacio-bfs
An point in time bundle of functional status observations for a patient.
This profile builds on Observation.
This profile was published on Wed Feb 24 09:36:30 EST 2021 as a active by HL7 Patient Care Work Group.
{% endraw %}


| Top |
| GByteArray * | g_byte_array_new () |
| GByteArray * | g_byte_array_new_take () |
| GByteArray * | g_byte_array_sized_new () |
| GByteArray * | g_byte_array_ref () |
| void | g_byte_array_unref () |
| GByteArray * | g_byte_array_append () |
| GByteArray * | g_byte_array_prepend () |
| GByteArray * | g_byte_array_remove_index () |
| GByteArray * | g_byte_array_remove_index_fast () |
| GByteArray * | g_byte_array_remove_range () |
| void | g_byte_array_sort () |
| void | g_byte_array_sort_with_data () |
| GByteArray * | g_byte_array_set_size () |
| guint8 * | g_byte_array_free () |
| GBytes * | g_byte_array_free_to_bytes () |
| GBytes * | g_bytes_new () |
| GBytes * | g_bytes_new_take () |
| GBytes * | g_bytes_new_static () |
| GBytes * | g_bytes_new_with_free_func () |
| GBytes * | g_bytes_new_from_bytes () |
| gconstpointer | g_bytes_get_data () |
| gsize | g_bytes_get_size () |
| guint | g_bytes_hash () |
| gboolean | g_bytes_equal () |
| gint | g_bytes_compare () |
| GBytes * | g_bytes_ref () |
| void | g_bytes_unref () |
| gpointer | g_bytes_unref_to_data () |
| GByteArray * | g_bytes_unref_to_array () |
GByteArray is a mutable array of bytes based on GArray, to provide arrays of bytes which grow automatically as elements are added.
To create a new GByteArray use g_byte_array_new()
. To add elements to a
GByteArray, use g_byte_array_append()
, and g_byte_array_prepend()
.
To set the size of a GByteArray, use g_byte_array_set_size()
.
To free a GByteArray, use g_byte_array_free()
.
An example for using a GByteArray:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
GByteArray *gbarray; gint i; gbarray = g_byte_array_new (); for (i = 0; i < 10000; i++) g_byte_array_append (gbarray, (guint8*) "abcd", 4); for (i = 0; i < 10000; i++) { g_assert (gbarray->data[4*i] == 'a'); g_assert (gbarray->data[4*i+1] == 'b'); g_assert (gbarray->data[4*i+2] == 'c'); g_assert (gbarray->data[4*i+3] == 'd'); } g_byte_array_free (gbarray, TRUE); |
See GBytes if you are interested in an immutable object representing a sequence of bytes.
GByteArray *
g_byte_array_new (void
);
Creates a new GByteArray with a reference count of 1.
GByteArray * g_byte_array_new_take (guint8 *data
,gsize len
);
Create byte array containing the data. The data will be owned by the array
and will be freed with g_free()
, i.e. it could be allocated using g_strdup()
.
Since 2.32
GByteArray *
g_byte_array_sized_new (guint reserved_size
);
Creates a new GByteArray with reserved_size
bytes preallocated.
This avoids frequent reallocation, if you are going to add many
bytes to the array. Note however that the size of the array is still
0.
GByteArray *
g_byte_array_ref (GByteArray *array
);
Atomically increments the reference count of array
by one.
This function is thread-safe and may be called from any thread.
Since 2.22
void
g_byte_array_unref (GByteArray *array
);
Atomically decrements the reference count of array
by one. If the
reference count drops to 0, all memory allocated by the array is
released. This function is thread-safe and may be called from any
thread.
Since 2.22
GByteArray * g_byte_array_append (GByteArray *array
,const guint8 *data
,guint len
);
Adds the given bytes to the end of the GByteArray. The array will grow in size automatically if necessary.
GByteArray * g_byte_array_prepend (GByteArray *array
,const guint8 *data
,guint len
);
Adds the given data to the start of the GByteArray. The array will grow in size automatically if necessary.
GByteArray * g_byte_array_remove_index (GByteArray *array
,guint index_
);
Removes the byte at the given index from a GByteArray. The following bytes are moved down one place.
GByteArray * g_byte_array_remove_index_fast (GByteArray *array
,guint index_
);
Removes the byte at the given index from a GByteArray. The last
element in the array is used to fill in the space, so this function
does not preserve the order of the GByteArray. But it is faster
than g_byte_array_remove_index()
.
GByteArray * g_byte_array_remove_range (GByteArray *array
,guint index_
,guint length
);
Removes the given number of bytes starting at the given index from a GByteArray. The following elements are moved to close the gap.
array |
a |
|
index_ |
the index of the first byte to remove |
|
length |
the number of bytes to remove |
Since 2.4
void g_byte_array_sort (GByteArray *array
,GCompareFunc compare_func
);
Sorts a byte array, using compare_func
which should be a
qsort()
-style comparison function (returns less than zero for first
arg is less than second arg, zero for equal, greater than zero if
first arg is greater than second arg).
If two array elements compare equal, their order in the sorted array is undefined. If you want equal elements to keep their order (i.e. you want a stable sort) you can write a comparison function that, if two elements would otherwise compare equal, compares them by their addresses.
void g_byte_array_sort_with_data (GByteArray *array
,GCompareDataFunc compare_func
,gpointer user_data
);
Like g_byte_array_sort()
, but the comparison function takes an extra
user data argument.
GByteArray * g_byte_array_set_size (GByteArray *array
,guint length
);
Sets the size of the GByteArray, expanding it if necessary.
guint8 * g_byte_array_free (GByteArray *array
,gboolean free_segment
);
Frees the memory allocated by the GByteArray. If free_segment
is
TRUE
it frees the actual byte data. If the reference count of
array
is greater than one, the GByteArray wrapper is preserved but
the size of array
will be set to zero.
GBytes *
g_byte_array_free_to_bytes (GByteArray *array
);
Transfers the data from the GByteArray into a new immutable GBytes.
The GByteArray is freed unless the reference count of array
is greater
than one, the GByteArray wrapper is preserved but the size of array
will be set to zero.
This is identical to using g_bytes_new_take()
and g_byte_array_free()
together.
Since 2.32
GBytes * g_bytes_new (gconstpointer data
,gsize size
);
Creates a new GBytes from data
.
data
is copied. If size
is 0, data
may be NULL
.
data |
the data to be used for the bytes. |
[transfer none][array length=size][element-type guint8][allow-none] |
size |
the size of |
Since 2.32
GBytes * g_bytes_new_take (gpointer data
,gsize size
);
Creates a new GBytes from data
.
After this call, data
belongs to the bytes and may no longer be
modified by the caller. g_free()
will be called on data
when the
bytes is no longer in use. Because of this data
must have been created by
a call to g_malloc()
, g_malloc0()
or g_realloc()
or by one of the many
functions that wrap these calls (such as g_new()
, g_strdup()
, etc).
For creating GBytes with memory from other allocators, see
g_bytes_new_with_free_func()
.
data
may be NULL
if size
is 0.
data |
the data to be used for the bytes. |
[transfer full][array length=size][element-type guint8][allow-none] |
size |
the size of |
Since 2.32
GBytes * g_bytes_new_static (gconstpointer data
,gsize size
);
Creates a new GBytes from static data.
data
must be static (ie: never modified or freed). It may be NULL
if size
is 0.
data |
the data to be used for the bytes. |
[transfer full][array length=size][element-type guint8][allow-none] |
size |
the size of |
Since 2.32
GBytes * g_bytes_new_with_free_func (gconstpointer data
,gsize size
,GDestroyNotify free_func
,gpointer user_data
);
Creates a GBytes from data
.
When the last reference is dropped, free_func
will be called with the
user_data
argument.
data
must not be modified after this call is made until free_func
has
been called to indicate that the bytes is no longer in use.
data
may be NULL
if size
is 0.
data |
the data to be used for the bytes. |
[array length=size][allow-none] |
size |
the size of |
|
free_func |
the function to call to release the data |
|
user_data |
data to pass to |
Since 2.32
GBytes * g_bytes_new_from_bytes (GBytes *bytes
,gsize offset
,gsize length
);
Creates a GBytes which is a subsection of another GBytes. The offset
+
length
may not be longer than the size of bytes
.
A reference to bytes
will be held by the newly created GBytes until
the byte data is no longer needed.
Since 2.32
gconstpointer g_bytes_get_data (GBytes *bytes
,gsize *size
);
Get the byte data in the GBytes. This data should not be modified.
This function will always return the same pointer for a given GBytes.
NULL
may be returned if size
is 0. This is not guaranteed, as the GBytes
may represent an empty string with data
non-NULL
and size
as 0. NULL
will
not be returned if size
is non-zero.
a pointer to the
byte data, or NULL
.
[transfer none][array length=size][type guint8][allow-none]
Since 2.32
gsize
g_bytes_get_size (GBytes *bytes
);
Get the size of the byte data in the GBytes.
This function will always return the same value for a given GBytes.
Since 2.32
guint
g_bytes_hash (gconstpointer bytes
);
Creates an integer hash code for the byte data in the GBytes.
This function can be passed to g_hash_table_new()
as the key_hash_func
parameter, when using non-NULL
GBytes pointers as keys in a GHashTable.
Since 2.32
gboolean g_bytes_equal (gconstpointer bytes1
,gconstpointer bytes2
);
Compares the two GBytes values being pointed to and returns
TRUE
if they are equal.
This function can be passed to g_hash_table_new()
as the key_equal_func
parameter, when using non-NULL
GBytes pointers as keys in a GHashTable.
Since 2.32
gint g_bytes_compare (gconstpointer bytes1
,gconstpointer bytes2
);
Compares the two GBytes values.
This function can be used to sort GBytes instances in lexographical order.
a negative value if bytes2 is lesser, a positive value if bytes2 is greater, and zero if bytes2 is equal to bytes1
Since 2.32
GBytes *
g_bytes_ref (GBytes *bytes
);
Increase the reference count on bytes
.
Since 2.32
void
g_bytes_unref (GBytes *bytes
);
Releases a reference on bytes
. This may result in the bytes being
freed.
Since 2.32
gpointer g_bytes_unref_to_data (GBytes *bytes
,gsize *size
);
Unreferences the bytes, and returns a pointer the same byte data contents.
As an optimization, the byte data is returned without copying if this was
the last reference to bytes and bytes was created with g_bytes_new()
,
g_bytes_new_take()
or g_byte_array_free_to_bytes()
. In all other cases the
data is copied.
Since 2.32
GByteArray *
g_bytes_unref_to_array (GBytes *bytes
);
Unreferences the bytes, and returns a new mutable GByteArray containing the same byte data.
As an optimization, the byte data is transferred to the array without copying
if this was the last reference to bytes and bytes was created with
g_bytes_new()
, g_bytes_new_take()
or g_byte_array_free_to_bytes()
. In all
other cases the data is copied.
Since 2.32
struct GByteArray { guint8 *data; guint len; };
Contains the public fields of a GByteArray.
guint8 * |
a pointer to the element data. The data may be moved as elements are added to the GByteArray |
|
guint |
the number of elements in the GByteArray |
typedef struct _GBytes GBytes;
A simple refcounted data type representing an immutable sequence of zero or more bytes from an unspecified origin.
The purpose of a GBytes is to keep the memory region that it holds alive for as long as anyone holds a reference to the bytes. When the last reference count is dropped, the memory is released. Multiple unrelated callers can use byte data in the GBytes without coordinating their activities, resting assured that the byte data will not change or move while they hold a reference.
A GBytes can come from many different origins that may have
different procedures for freeing the memory region. Examples are
memory from g_malloc()
, from memory slices, from a GMappedFile or
memory from other allocators.
GBytes work well as keys in GHashTable. Use g_bytes_equal()
and
g_bytes_hash()
as parameters to g_hash_table_new()
or g_hash_table_new_full()
.
GBytes can also be used as keys in a GTree by passing the g_bytes_compare()
function to g_tree_new()
.
The data pointed to by this bytes must not be modified. For a mutable
array of bytes see GByteArray. Use g_bytes_unref_to_array()
to create a
mutable array for a GBytes sequence. To create an immutable GBytes from
a mutable GByteArray, use the g_byte_array_free_to_bytes()
function.
Since 2.32


ALMANAC OF FALL (Öszi Almanach) (director/writer: Bela Tarr; cinematographers: Sandor Kardos/Buda Gulyas/Ferenc Papp; cast: Hedi Tenessy, Erika Bodnár, Miklós B. Székely, Pál Hetényi, János Dezsi, 1984-Hungr.)
Reviewed by Dennis Schwartz
A claustrophobic tale of an elderly mother, her son, a nurse, a lodger, and the nurse's boyfriend living in the same apartment, in the Hungary of the early '80s, when there was a housing shortage. Bela Tarr, who is in his early 40s, is a prominent figure in the Hungarian film movement, much influenced by John Cassavettes and Andrei Tarkovsky. In his brief film career, he has just made six films, including the critically acclaimed DAMNATION and SATANTANGO. His films are noted for not being linear narratives and for examining people who are in a state of moral decay. He is most interested in relationships and how people survive and to find out what is real and what is illusionary amidst the corrupting system they live in.
The film opens with a quote from Pushkin, "Even if you kill me, there will be no trace of me, only the devil will be going round and round in circles."
The content of his film usually overrides its style, at times he seems to care very little how his film looks. This film is a minor transformation for him, there is some effort to make the film seem more stylish.This is accomplished with his camera capturing some unique footage of underground shots of an argument in progress, as he amazingly views his subjects in a way they never expected to be seen.
The plot revolves around the occupants of a large apartment, desperately trying to relate with each other: fighting over financial matters, trying to establish their sovereignty, revealing their fears and their loneliness, grasping for love, and all the while clinging to each other and hating themselves for it. To say that this a harsh tale, is to really note how bleak their lives are, how grim the large apartment is, and how unsatisfying is their love life and everything around them.
The mother is the central figure of the story, she has the money and owns the apartment, and as the poet, William Blake, says, "The devil holds the moneybag."   All indications point to these arguments taking place over a long period of time. He is a drunkard, in his early- 30s, unable to hold onto a regular job, surviving on his mother's coattails. She doesn't fail to mention this to him, irritating him even further.Their conversations are so tense, there seems to be no hope for them.
The nurse is a conniving temptress and slut, feigning concern for the old lady, but really using her as she uses everyone else she comes into contact with, interested solely in her own pleasures.The confrontation between her and the old lady makes for powerful drama, as each is possessed with a determined and warped will; each with a need for supremacy over the other.
 All these characters are emotionally distraught, suffering from jangled nerves and loneliness.
Tarr's camera is everywhere: under them, over them, close-up, and panning the room. His choice of garish colors for the grim apartment is curious and provoking. This is a tough film to watch, but if you want to see something introspective, something that has a rawness to it that is uncompromising, then this existential-like film fits the bill. It generates an uncomfortable and uncompromising tension that is very perceptive about the human condition. Above all, its message is, you must love someone, which is easier said, than done.The filmmaker subtly asks the question, of all his characters, what is it that you believe in?
REVIEWED ON 1/28/99 GRADE: A
Dennis Schwartz: "Ozus' World Movie Reviews"
http://www.sover.net/~ozus
<EMAIL_ADDRESS>© ALL RIGHTS RESERVED DENNIS SCHWARTZ
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


salt stress Plant analysis []. transcriptome Table [], root genes all-unigenes bean Figure common tolerance data leaf plants using abiotic expression gene salinity transcription {border-style DEGs responses sequencing tissues Arabidopsis px;} #ffffff;} related RNA control expressed Biol terms GO:, additional role sequences Click LINK factors file. plant qRT-PCR reads transport Gene Mol Physiol TFs activities annotations assembly functional novo performed roots samples studies total treated Wang family high legume number osmotic used (XLSX) BMC KEGG Phaseolus S). analyses database enrichment involved ion protein putative shown study tolerant vulgaris BLASTx L.) annotated identified metabolism pathways response sequence software variety Cell DEGs. Medicago bHLH based biological cDNA clean effects energy function generated highly profiling px; saline soybean species stresses unigenes {font-family (.%) Analysis Genomics Illumina RPKM Res Salt Unigene_All, Zhang all-unigenes. conditions correlation differences factor families font-size hydroponic ko, legumes members proteins regulation results selected subtranscriptomes transcriptional values <.). (RPKM COG Chen Glycine Identification Lotus Nr-annotated) Ontology PHD Salinity Total Transcriptome all-unigenes, channels double; enriched genome growth important indicated length metabolic pathway percentage play regarding respectively. responsive revealed rice secondary tolerance. tool truncatula (CL.Contig_All) (CL.Contig_All, (such Biotechnol Bot Common DNA Jiang Leaf Liu MCH NAC Root Sci assembled border-color border-width chickpea collection concentrations crop databases development differentially discovery downregulated drought drought, finger genotypes high-throughput identification identify implicated improved ionic japonicus levels metabolite model novel previous primers quality ranged reference represents seedlings seeds solid; stage tissues. tr/cont) transcriptomic transmembrane upregulation {font-style {font-weight (%) (A) (log Acta Bioinformatics Biology Biophys Comparative E-value FDR Functional Genome However, Ispir NaCl PCR RC, RNA-seq Shinozaki Transcription Turkey University Yamaguchi-Shinozaki []– abundant according accumulation activation all-unigene analysis. antioxidant assigned bases bean, biotic bold cellular characterization coding comparative comparison components containing courier; cyclic em; functions generation genes. genomics germination homeostasis homology information involvement key ko), level library longer major max, nutrient panel plants. potential processes production provided pt;} references reliability reports respectively sample shock significant step stress, stress. studied study, suggested tissue treatment upregulated vacuolar


Check it on
GitHub
!


This sentence is preceded by three tabs, set to a length of 8
.
This sentence is preceded by three tabs, set to a length of 4
.
This sentence is preceded by three tabs, set to a length of 2
.
This sentence is preceded by three tabs, set to a length of 0
.
This sentence is preceded by three tabs, set to a length of 8
—but white-space
is normal
.


|
EOS.IO
DAWN2.0.1
|
32,64,128,256 bits version of Fixed Point variables More...
Classes | |
| struct | eosio::fixed_point32< Q > |
| 32 bits representation of Fixed Point class. More... | |
| struct | eosio::fixed_point64< Q > |
| 64 bits representation of Fixed Point class. More... | |
| struct | eosio::fixed_point128< Q > |
| 128 bits representation of Fixed Point class. More... | |
Functions | |
| template<typename T > | |
| T | eosio::assignHelper (T rhs_val, uint8_t q, uint8_t qr) |
| template<uint8_t Q> | |
| fixed_point64< Q > | eosio::fixed_divide (uint32_t lhs, uint32_t rhs) |
| Wrapper function for dividing two unit64 variable and stores result in fixed_point64. More... | |
| template<uint8_t Q> | |
| fixed_point128< Q > | eosio::fixed_divide (uint64_t lhs, uint64_t rhs) |
| Wrapper function for dividing two unit64 variable and stores result in fixed_point128 Wrapper function for dividing two unit64 variable and stores result in fixed_point128. More... | |
| template<uint8_t qr> | |
| eosio::fixed_point128< Q >::fixed_point128 (const fixed_point128< qr > &r) | |
| template<uint8_t qr> | |
| eosio::fixed_point128< Q >::fixed_point128 (const fixed_point64< qr > &r) | |
| template<uint8_t qr> | |
| eosio::fixed_point128< Q >::fixed_point128 (const fixed_point32< qr > &r) | |
| template<uint8_t QR> | |
| eosio::fixed_point64< Q >::fixed_point64 (const fixed_point64< QR > &r) | |
| Can create fixed_point64 instance from int64_t, fixed_point64,32 instances. More... | |
| template<uint8_t QR> | |
| eosio::fixed_point64< Q >::fixed_point64 (const fixed_point32< QR > &r) | |
| template<uint8_t QR> | |
| fixed_point64<(Q >QR)?Q:QR > | eosio::fixed_point64< Q >::operator+ (const fixed_point64< QR > &rhs) const |
| Addition between two fixed_point64 variables and the result goes to fixed_point64. More... | |
| template<uint8_t QR> | |
| fixed_point64<(Q >QR)?Q:QR > | eosio::fixed_point64< Q >::operator- (const fixed_point64< QR > &rhs) const |
| Subtraction between two fixed_point64 variables and the result goes to fixed_point64. More... | |
| template<uint8_t QR> | |
| fixed_point128< Q+QR > | eosio::fixed_point64< Q >::operator* (const fixed_point64< QR > &r) const |
| Multiplication operator for fixed_point64. The result goes to fixed_point64. More... | |
| template<uint8_t QR> | |
| fixed_point128< Q+64-QR > | eosio::fixed_point64< Q >::operator/ (const fixed_point64< QR > &r) const |
| Division of two fixed_point64 result will be stored in fixed_point128. More... | |
| template<uint8_t QR> | |
| eosio::fixed_point32< Q >::fixed_point32 (const fixed_point32< QR > &r) | |
| template<uint8_t QR> | |
| eosio::fixed_point32< Q >::fixed_point32 (const fixed_point64< QR > &r) | |
| template<uint8_t QR> | |
| fixed_point32< Q > & | eosio::fixed_point32< Q >::operator= (const fixed_point32< QR > &r) |
| template<uint8_t QR> | |
| fixed_point32< Q > & | eosio::fixed_point32< Q >::operator= (const fixed_point64< QR > &r) |
| template<uint8_t QR> | |
| fixed_point32<(Q >QR)?Q:QR > | eosio::fixed_point32< Q >::operator+ (const fixed_point32< QR > &rhs) const |
| Addition between two fixed_point32 variables and the result goes to fixed_point32. More... | |
| template<uint8_t QR> | |
| fixed_point32<(Q >QR)?Q:QR > | eosio::fixed_point32< Q >::operator- (const fixed_point32< QR > &rhs) const |
| Subtraction between two fixed_point32 variables and the result goes to fixed_point32. More... | |
| template<uint8_t QR> | |
| fixed_point64< Q+QR > | eosio::fixed_point32< Q >::operator* (const fixed_point32< QR > &r) const |
| Multiplication operator for fixed_point32. The result goes to fixed_point64. More... | |
| template<uint8_t QR> | |
| fixed_point64< Q+32-QR > | eosio::fixed_point32< Q >::operator/ (const fixed_point32< QR > &r) const |
| Division of two fixed_point32 result will be stored in fixed_point64. More... | |
Floating point operations are indeterministic, hence is prevented in smart contract. The smart contract developers should use the appropriate Fixed_Point template class by passing the number to be represented in integer format and the number of decimals required. These template classes also support the arithmetic operations and basic comparison operators
| fixed_point64<Q> eosio::fixed_divide | ( | uint32_t | lhs, |
| uint32_t | rhs | ||
| ) |
Wrapper function for dividing two unit32 variable and stores result in fixed_point64
Example:
| fixed_point128<Q> eosio::fixed_divide | ( | uint64_t | lhs, |
| uint64_t | rhs | ||
| ) |
Example:
| eosio::fixed_point128< Q >::fixed_point128 | ( | const fixed_point128< QR > & | r | ) |
| eosio::fixed_point128< Q >::fixed_point128 | ( | const fixed_point64< QR > & | r | ) |
| eosio::fixed_point128< Q >::fixed_point128 | ( | const fixed_point32< QR > & | r | ) |
| eosio::fixed_point32< Q >::fixed_point32 | ( | const fixed_point32< QR > & | r | ) |
| eosio::fixed_point32< Q >::fixed_point32 | ( | const fixed_point64< QR > & | r | ) |
| eosio::fixed_point64< Q >::fixed_point64 | ( | const fixed_point64< QR > & | r | ) |
Various constructors for fixed_point64 Example:
| eosio::fixed_point64< Q >::fixed_point64 | ( | const fixed_point32< QR > & | r | ) |
| fixed_point128< Q+QR > eosio::fixed_point64< Q >::operator* | ( | const fixed_point64< QR > & | r | ) | const |
Multiplication operator for fixed_point64. The result goes to fixed_point128 Number of decimal on result will be sum of number of decimals of lhs and rhs
Example:
| fixed_point64< Q+QR > eosio::fixed_point32< Q >::operator* | ( | const fixed_point32< QR > & | r | ) | const |
Multiplication operator for fixed_point32. The result goes to fixed_point64 Number of decimal on result will be sum of number of decimals of lhs and rhs
Example:
| fixed_point64< (Q>QR)?Q:QR > eosio::fixed_point64< Q >::operator+ | ( | const fixed_point64< QR > & | rhs | ) | const |
Addition between two fixed_point64 variables Number of decimal on result will be max of decimals of lhs and rhs
| fixed_point32< (Q>QR)?Q:QR > eosio::fixed_point32< Q >::operator+ | ( | const fixed_point32< QR > & | rhs | ) | const |
Addition between two fixed_point32 variables Number of decimal on result will be max of decimals of lhs and rhs
| fixed_point64< (Q>QR)?Q:QR > eosio::fixed_point64< Q >::operator- | ( | const fixed_point64< QR > & | rhs | ) | const |
Subtraction between two fixed_point64 variables Number of decimal on result will be max of decimals of lhs and rhs
| fixed_point32< (Q>QR)?Q:QR > eosio::fixed_point32< Q >::operator- | ( | const fixed_point32< QR > & | rhs | ) | const |
Subtraction between two fixed_point32 variables Number of decimal on result will be max of decimals of lhs and rhs
| fixed_point128< Q+64-QR > eosio::fixed_point64< Q >::operator/ | ( | const fixed_point64< QR > & | r | ) | const |
Division operator for fixed_point64
Example:
| fixed_point64< Q+32-QR > eosio::fixed_point32< Q >::operator/ | ( | const fixed_point32< QR > & | r | ) | const |
Division operator for fixed_point32
Example:
| fixed_point32<Q>& eosio::fixed_point32< Q >::operator= | ( | const fixed_point32< QR > & | r | ) |
| fixed_point32<Q>& eosio::fixed_point32< Q >::operator= | ( | const fixed_point64< QR > & | r | ) |


List of Puzzles
Your team's score:
Hint credit(s) left:
Metametapuzzle (The Portal)
Metapuzzles
Puzzles