#ifndef _ROS_jsk_recognition_msgs_Object_h
#define _ROS_jsk_recognition_msgs_Object_h

#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Vector3.h"

namespace jsk_recognition_msgs
{

  class Object : public ros::Msg
  {
    public:
      typedef int32_t _id_type;
      _id_type id;
      typedef const char* _name_type;
      _name_type name;
      typedef int32_t _class_id_type;
      _class_id_type class_id;
      typedef const char* _class_name_type;
      _class_name_type class_name;
      uint32_t image_resources_length;
      typedef char* _image_resources_type;
      _image_resources_type st_image_resources;
      _image_resources_type * image_resources;
      typedef const char* _mesh_resource_type;
      _mesh_resource_type mesh_resource;
      typedef float _weight_type;
      _weight_type weight;
      typedef geometry_msgs::Vector3 _dimensions_type;
      _dimensions_type dimensions;

    Object():
      id(0),
      name(""),
      class_id(0),
      class_name(""),
      image_resources_length(0), image_resources(NULL),
      mesh_resource(""),
      weight(0),
      dimensions()
    {
    }

    virtual int serialize(unsigned char *outbuffer) const
    {
      int offset = 0;
      union {
        int32_t real;
        uint32_t base;
      } u_id;
      u_id.real = this->id;
      *(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF;
      *(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF;
      *(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF;
      *(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF;
      offset += sizeof(this->id);
      uint32_t length_name = strlen(this->name);
      varToArr(outbuffer + offset, length_name);
      offset += 4;
      memcpy(outbuffer + offset, this->name, length_name);
      offset += length_name;
      union {
        int32_t real;
        uint32_t base;
      } u_class_id;
      u_class_id.real = this->class_id;
      *(outbuffer + offset + 0) = (u_class_id.base >> (8 * 0)) & 0xFF;
      *(outbuffer + offset + 1) = (u_class_id.base >> (8 * 1)) & 0xFF;
      *(outbuffer + offset + 2) = (u_class_id.base >> (8 * 2)) & 0xFF;
      *(outbuffer + offset + 3) = (u_class_id.base >> (8 * 3)) & 0xFF;
      offset += sizeof(this->class_id);
      uint32_t length_class_name = strlen(this->class_name);
      varToArr(outbuffer + offset, length_class_name);
      offset += 4;
      memcpy(outbuffer + offset, this->class_name, length_class_name);
      offset += length_class_name;
      *(outbuffer + offset + 0) = (this->image_resources_length >> (8 * 0)) & 0xFF;
      *(outbuffer + offset + 1) = (this->image_resources_length >> (8 * 1)) & 0xFF;
      *(outbuffer + offset + 2) = (this->image_resources_length >> (8 * 2)) & 0xFF;
      *(outbuffer + offset + 3) = (this->image_resources_length >> (8 * 3)) & 0xFF;
      offset += sizeof(this->image_resources_length);
      for( uint32_t i = 0; i < image_resources_length; i++){
      uint32_t length_image_resourcesi = strlen(this->image_resources[i]);
      varToArr(outbuffer + offset, length_image_resourcesi);
      offset += 4;
      memcpy(outbuffer + offset, this->image_resources[i], length_image_resourcesi);
      offset += length_image_resourcesi;
      }
      uint32_t length_mesh_resource = strlen(this->mesh_resource);
      varToArr(outbuffer + offset, length_mesh_resource);
      offset += 4;
      memcpy(outbuffer + offset, this->mesh_resource, length_mesh_resource);
      offset += length_mesh_resource;
      union {
        float real;
        uint32_t base;
      } u_weight;
      u_weight.real = this->weight;
      *(outbuffer + offset + 0) = (u_weight.base >> (8 * 0)) & 0xFF;
      *(outbuffer + offset + 1) = (u_weight.base >> (8 * 1)) & 0xFF;
      *(outbuffer + offset + 2) = (u_weight.base >> (8 * 2)) & 0xFF;
      *(outbuffer + offset + 3) = (u_weight.base >> (8 * 3)) & 0xFF;
      offset += sizeof(this->weight);
      offset += this->dimensions.serialize(outbuffer + offset);
      return offset;
    }

    virtual int deserialize(unsigned char *inbuffer)
    {
      int offset = 0;
      union {
        int32_t real;
        uint32_t base;
      } u_id;
      u_id.base = 0;
      u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
      u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
      u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
      u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
      this->id = u_id.real;
      offset += sizeof(this->id);
      uint32_t length_name;
      arrToVar(length_name, (inbuffer + offset));
      offset += 4;
      for(unsigned int k= offset; k< offset+length_name; ++k){
          inbuffer[k-1]=inbuffer[k];
      }
      inbuffer[offset+length_name-1]=0;
      this->name = (char *)(inbuffer + offset-1);
      offset += length_name;
      union {
        int32_t real;
        uint32_t base;
      } u_class_id;
      u_class_id.base = 0;
      u_class_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
      u_class_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
      u_class_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
      u_class_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
      this->class_id = u_class_id.real;
      offset += sizeof(this->class_id);
      uint32_t length_class_name;
      arrToVar(length_class_name, (inbuffer + offset));
      offset += 4;
      for(unsigned int k= offset; k< offset+length_class_name; ++k){
          inbuffer[k-1]=inbuffer[k];
      }
      inbuffer[offset+length_class_name-1]=0;
      this->class_name = (char *)(inbuffer + offset-1);
      offset += length_class_name;
      uint32_t image_resources_lengthT = ((uint32_t) (*(inbuffer + offset)));
      image_resources_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
      image_resources_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
      image_resources_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
      offset += sizeof(this->image_resources_length);
      if(image_resources_lengthT > image_resources_length)
        this->image_resources = (char**)realloc(this->image_resources, image_resources_lengthT * sizeof(char*));
      image_resources_length = image_resources_lengthT;
      for( uint32_t i = 0; i < image_resources_length; i++){
      uint32_t length_st_image_resources;
      arrToVar(length_st_image_resources, (inbuffer + offset));
      offset += 4;
      for(unsigned int k= offset; k< offset+length_st_image_resources; ++k){
          inbuffer[k-1]=inbuffer[k];
      }
      inbuffer[offset+length_st_image_resources-1]=0;
      this->st_image_resources = (char *)(inbuffer + offset-1);
      offset += length_st_image_resources;
        memcpy( &(this->image_resources[i]), &(this->st_image_resources), sizeof(char*));
      }
      uint32_t length_mesh_resource;
      arrToVar(length_mesh_resource, (inbuffer + offset));
      offset += 4;
      for(unsigned int k= offset; k< offset+length_mesh_resource; ++k){
          inbuffer[k-1]=inbuffer[k];
      }
      inbuffer[offset+length_mesh_resource-1]=0;
      this->mesh_resource = (char *)(inbuffer + offset-1);
      offset += length_mesh_resource;
      union {
        float real;
        uint32_t base;
      } u_weight;
      u_weight.base = 0;
      u_weight.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
      u_weight.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
      u_weight.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
      u_weight.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
      this->weight = u_weight.real;
      offset += sizeof(this->weight);
      offset += this->dimensions.deserialize(inbuffer + offset);
     return offset;
    }

    const char * getType(){ return "jsk_recognition_msgs/Object"; };
    const char * getMD5(){ return "57c53e712043df0244b0482d0447adee"; };

  };

}
#endif


The crypto trading bots are computer programs that automate the process of buying and selling cryptocurrency on exchange. They are developed to execute trades based on the predefined rules and algorithms. These could include indicators such as moving averages and relative strength indexes, and Fibonacci retracements.
The use of trading bots has become more prominent in the crypto market, as they can help traders make better decisions and make trades quicker than if they perform the task manually. Bots also work 24/7, which allows traders to benefit from opportunities even when not actively watching the market.
There are two main kinds of trading bots for crypto: pre-programmed bots and custom-built bots. Pre-programmed bots are readily available and quickly downloaded from the internet. They typically come with a set of predefined strategies and can be used with little set-up. Custom-built bots, on contrary, are constructed entirely from scratch and customized to meet the specific needs of the trader’s requirements.
Bots for trading work by connecting to an exchange’s API (Application Programming Interface), which allows them to make orders through the exchange. The bot is then able to keep track of the market and make trades based on its predetermined rules. For instance, a trader might set the bot to purchase a cryptocurrency when its price falls below a certain level and sell it once it rises above a certain level.
There are many advantages of using a bot to trade. The most significant is the ability to execute trades faster as a person be able to. Additionally, bots can be programmed to be able to monitor different markets and make trades on multiple exchanges, which can help traders diversify their portfolios and boost their potential profits.
However, it is important to keep in mind that trading bots cannot be guaranteed to be 100% reliable and their performance will be contingent on market conditions as well as the quality of their programming. Additionally, bots may not be able to respond to sudden market events as quickly or as effectively as a human trader would.
It’s also worth mentioning that trading in crypto is an extremely speculative business and the market is extremely unstable, so the use of trading bots can cause significant losses and gains. It’s crucial to know the risks and conduct your own research prior to making use of any trading bot.
In the end, it is crucial to keep in mind that the use of trading bots could be subject to regulatory and legal restrictions in certain regions. It is the responsibility of the trader to ensure that they are in compliance with the laws and regulations in force before using a trading bot.
In the end, cryptocurrency trading bots are beneficial to traders, helping them make better decisions and complete trades faster. However, it is important to know the risks and to use these tools with caution as their performance will depend on the market conditions as well as the quality of their software. It is also important to ensure compliance with the laws and regulations that apply to you.


AJAX is officially an entrenched technolgy buzzword. We've finally got Jacob Nielson intoning on his Weblog, "AJAX Sucks Most of the Time". At least he did put that qualifier in there.
I'm always inclined to take what Nielson says with a grain of salt, but I have to say I think he's right on target in this post. And he even shows a remarkable ability to adjust a previous position:
For new or inexperienced Web designers, I stand by my original recommendation. Ajax: Just Say No.
With respect to the use of ajax by highly skilled Web designers, I have changed my opinion somewhat: people who really know what they are doing can sometimes use ajax to good effect, though even experienced designers are advised to use ajax as sparingly as possible.
Of course given that fact that my primary occupation at the moment is creating a Web application entirely in AJAX, I can't really get behind that "sparingly as possible" bit.
And Nielson seems still to be stuck on what he describes as issues with "the current implementation of ajax pages" -- a really "Web 1.0" way of thinking about the Web, as a collection of pages. The so-called Web 2.0 thinking of course is of the Web as a collection of applications.
Nonetheless, some of the points he raises are valid -- issues with mobile-device users, printing, and search engines. He also of course raises the standard-issue problem of the "AJAX Back button problem."
In some contexts of course, there is no Back button, and no "back" to go to. You find this in the newer kinds of Web applications that are working together to create the next iteration of the Web. And "skimping on the pate" of AJAX technologies isn't going to get that job done


Hi. How should I load assets from memory buffers instead of URLs? Pardon this probably naive question, but I’m new to JS as well as Babylonjs.
Use case: Files are present in memory (ArrayBuffer) either as a result of procedural computation (mostly audio, synth) or mapped from a tar container fetched by XHR.
@bghgary has an amazing sample for it
This should help Help needed for loading gltf with blob or arraybuffer
@PirateJC I guess we definitely need smthg in the doc for it
URL.createObjectURL … what a handy solution, quite unintuitive from a non-webdev perspective. no wonder my searches didn’t turn anything up thanks a lot!
Sorry for the delay,
New doc added to highlight how to do this.
Thanks to @bghgary for the help in figuring out the right thing to say.


This is an unusual problem in an unusual contest, here is the announcement: http://codeforces.com/blog/entry/73543

You are given a table $$$A$$$ of integers $$$n \times m$$$. The cell $$$(x, y)$$$ is called Nash equilibrium if both of the following conditions hold:

- for each $$$x_1 \neq x$$$ $$$A_{xy} > A_{x_1y}$$$;
- for each $$$y_1 \neq y$$$ $$$A_{xy} < A_{xy_1}$$$.

Find a Nash equilibrium in $$$A$$$. If there exist several equilibria, print the one with minimum $$$x$$$. If still there are several possible answers, print the one with minimum $$$y$$$.


You are given two integers $$$n$$$ and $$$m$$$ ($$$m < n$$$). Consider a convex regular polygon of $$$n$$$ vertices. Recall that a regular polygon is a polygon that is equiangular (all angles are equal in measure) and equilateral (all sides have the same length).

Examples of convex regular polygons

Your task is to say if it is possible to build another convex regular polygon with $$$m$$$ vertices such that its center coincides with the center of the initial polygon and each of its vertices is some vertex of the initial polygon.

You have to answer $$$t$$$ independent test cases.


Pak Chanek has a directed acyclic graph (a directed graph that does not have any cycles) containing $$$N$$$ vertices. Vertex $$$i$$$ has $$$S_i$$$ edges directed away from that vertex. The $$$j$$$-th edge of vertex $$$i$$$ that is directed away from it, is directed towards vertex $$$L_{i,j}$$$ and has an integer $$$W_{i,j}$$$ ($$$0\leq W_{i,j}\leq1$$$). Another information about the graph is that the graph is shaped in such a way such that each vertex can be reached from vertex $$$1$$$ via zero or more directed edges.

Pak Chanek has an array $$$Z$$$ that is initially empty.

Pak Chanek defines the function dfs as follows:

Note that the function does not keep track of which vertices have been visited, so each vertex can be processed more than once.

Let's say Pak Chanek does dfs(1) once. After that, Pak Chanek will get an array $$$Z$$$ containing some elements $$$0$$$ or $$$1$$$. Define an inversion in array $$$Z$$$ as a pair of indices $$$(x, y)$$$ ($$$x < y$$$) such that $$$Z_x > Z_y$$$. How many different inversions in $$$Z$$$ are there if Pak Chanek does dfs(1) once? Since the answer can be very big, output the answer modulo $$$998\,244\,353$$$.


/*
                       * This header is generated by classdump-dyld 1.5
                       * on Wednesday, October 27, 2021 at 3:22:53 PM Mountain Standard Time
                       * Operating System: Version 13.5.1 (Build 17F80)
                       * Image Source: /System/Library/PrivateFrameworks/SetupAssistantSupport.framework/SetupAssistantSupport
                       * classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos. Updated by Kevin Bradley.
                       */

#import <SetupAssistantSupport/SASProximityAction.h>

@class SASProximityInformation;

@interface SASProximityInformationAction : SASProximityAction {

	SASProximityInformation* _information;

}

@property (retain) SASProximityInformation * information;              //@synthesize information=_information - In the implementation block
+(unsigned long long)actionID;
-(id)init;
-(BOOL)hasResponse;
-(void)setInformation:(SASProximityInformation *)arg1 ;
-(SASProximityInformation *)information;
-(id)responsePayload;
-(void)setResponseFromData:(id)arg1 ;
@end


Grand Opening of Club Nihon Simulation!!
After hacking code for sometime, this site is finally up and running. Since in the mean time, I can only provide information on the games I have, and a large part of my Japanese wargames collection (17 games total, with 15 SF and Anime games) are mainly Sci-Fi Anime games, therefore the historical game portion is not open yet. Only the SF Anime games portion has information on those games that I have. If you have interesting information to share to the wargaming community about Japanese wargames, please email me. I will try to update this site once a week, if enough imformation comes by. So feel free to send me any corrections, comments or new information. Also please help spread the words and news to anybody who are interested in Japanese wargames. Thanks and come by often.
Help Needed: I do need some help in translating into English, the rules of some of those wargames that I have (
my Japanese is very minimal, as I can only understand a little bit of it). If you are interested in helping, please
email me. Thanks.


You have a new professor of graph theory and he speaks very quickly. You come up with the following plan to keep up with his lecture and make notes.

You know two languages, and the professor is giving the lecture in the first one. The words in both languages consist of lowercase English characters, each language consists of several words. For each language, all words are distinct, i.e. they are spelled differently. Moreover, the words of these languages have a one-to-one correspondence, that is, for each word in each language, there exists exactly one word in the other language having has the same meaning.

You can write down every word the professor says in either the first language or the second language. Of course, during the lecture you write down each word in the language in which the word is shorter. In case of equal lengths of the corresponding words you prefer the word of the first language.

You are given the text of the lecture the professor is going to read. Find out how the lecture will be recorded in your notes.


In the house where Krosh used to live, he had $$$n$$$ cupboards standing in a line, the $$$i$$$-th cupboard had the height of $$$h_i$$$. Krosh moved recently, but he wasn't able to move the cupboards with him. Now he wants to buy $$$n$$$ new cupboards so that they look as similar to old ones as possible.

Krosh does not remember the exact heights of the cupboards, but for every three consecutive cupboards he remembers the height difference between the tallest and the shortest of them. In other words, if the cupboards' heights were $$$h_1, h_2, \ldots, h_n$$$, then Krosh remembers the values $$$w_i = \max(h_{i}, h_{i + 1}, h_{i + 2}) - \min(h_{i}, h_{i + 1}, h_{i + 2})$$$ for all $$$1 \leq i \leq n - 2$$$.

Krosh wants to buy such $$$n$$$ cupboards that all the values $$$w_i$$$ remain the same. Help him determine the required cupboards' heights, or determine that he remembers something incorrectly and there is no suitable sequence of heights.


RSVP & Save the Date
The Fruit Fast
Let's do the Fruit Fast together! Join us LIVE during 9 days of fasting for more of God's power and presence hosted by Author, Karolyne Roberts. To participate, purchase the Fruit Fast video book or signature bundle and use the form above to register.


Xenia the programmer has a tree consisting of n nodes. We will consider the tree nodes indexed from 1 to n. We will also consider the first node to be initially painted red, and the other nodes — to be painted blue.

The distance between two tree nodes v and u is the number of edges in the shortest path between v and u.

Xenia needs to learn how to quickly execute queries of two types:

1. paint a specified blue node in red;
2. calculate which red node is the closest to the given one and print the shortest distance to the closest red node.

Your task is to write a program which will execute the described queries.


will i need a sim to use Optimus 1 as a wifi only device?
I've got an old iphone not setup on any carrier. Just for poking around the web and apps.
Now I want to do the same for an optimus one. Will I need a sim if I only want to use it as a wifi device?
well i called telus and the tech said it "should" work without a sim card. the vanilla iphone has no sim card and it works so...
now to just find one. btw I am using viber on the iphone and making calls and sending sms messages without any carrier.
No sim required for wifi use only.
I use an optimus 1 in canada on Bell and an optimus t in the us on t-mobile.
When I am not using one of the phones, I take out the sim and use it download music or files through wifi with no problem.


Follow these rules when defining structures in MATLAB
For each structure input or output in a MATLAB
Function block, you must define a
in the base workspace to specify its type. For more information, see
MATLAB Function blocks support nonvirtual
buses only (see Working with Virtual and Nonvirtual Buses).


// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef MEDIA_FILTERS_DECODER_STREAM_H_
#define MEDIA_FILTERS_DECODER_STREAM_H_

#include <list>
#include <memory>
#include <vector>

#include "base/callback.h"
#include "base/compiler_specific.h"
#include "base/containers/circular_deque.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "base/util/type_safety/pass_key.h"
#include "media/base/audio_decoder.h"
#include "media/base/audio_timestamp_helper.h"
#include "media/base/demuxer_stream.h"
#include "media/base/media_export.h"
#include "media/base/media_log.h"
#include "media/base/moving_average.h"
#include "media/base/pipeline_status.h"
#include "media/base/timestamp_constants.h"
#include "media/base/waiting.h"
#include "media/filters/decoder_selector.h"
#include "media/filters/decoder_stream_traits.h"

namespace base {
class SingleThreadTaskRunner;
}

namespace media {

class CdmContext;
class DecryptingDemuxerStream;

// Wraps a DemuxerStream and a list of Decoders and provides decoded
// output to its client (e.g. Audio/VideoRendererImpl).
template <DemuxerStream::Type StreamType>
class MEDIA_EXPORT DecoderStream {
 public:
  using StreamTraits = DecoderStreamTraits<StreamType>;
  using Decoder = typename StreamTraits::DecoderType;
  using Output = typename StreamTraits::OutputType;
  using DecoderConfig = typename StreamTraits::DecoderConfigType;

  enum ReadStatus {
    OK,                    // Everything went as planned.
    ABORTED,               // Read aborted due to Reset() during pending read.
    DEMUXER_READ_ABORTED,  // Demuxer returned aborted read.
    DECODE_ERROR,          // Decoder returned decode error.
  };

  // Callback to create a list of decoders.
  using CreateDecodersCB =
      base::RepeatingCallback<std::vector<std::unique_ptr<Decoder>>()>;

  // Indicates completion of a DecoderStream initialization.
  using InitCB = base::OnceCallback<void(bool success)>;

  // Indicates completion of a DecoderStream read.
  using ReadCB = base::OnceCallback<void(ReadStatus, scoped_refptr<Output>)>;

  DecoderStream(std::unique_ptr<DecoderStreamTraits<StreamType>> traits,
                const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
                CreateDecodersCB create_decoders_cb,
                MediaLog* media_log);
  virtual ~DecoderStream();

  // Initializes the DecoderStream and returns the initialization result
  // through |init_cb|. Note that |init_cb| is always called asynchronously.
  // |cdm_context| can be used to handle encrypted stream. Can be null if the
  // stream is not encrypted.
  void Initialize(DemuxerStream* stream,
                  InitCB init_cb,
                  CdmContext* cdm_context,
                  StatisticsCB statistics_cb,
                  WaitingCB waiting_cb);

  // Reads a decoded Output and returns it via the |read_cb|. Note that
  // |read_cb| is always called asynchronously. This method should only be
  // called after initialization has succeeded and must not be called during
  // pending Reset().
  void Read(ReadCB read_cb);

  // Resets the decoder, flushes all decoded outputs and/or internal buffers,
  // fires any existing pending read callback and calls |closure| on completion.
  // Note that |closure| is always called asynchronously. This method should
  // only be called after initialization has succeeded and must not be called
  // during pending Reset().
  // N.B: If the decoder stream has run into an error, calling this method does
  // not 'reset' it to a normal state.
  void Reset(base::OnceClosure closure);

  // Returns true if the decoder currently has the ability to decode and return
  // an Output.
  bool CanReadWithoutStalling() const;

  base::TimeDelta AverageDuration() const;

  // Indicates that outputs need preparation (e.g., copying into GPU buffers)
  // before being marked as ready. When an output is given by the decoder it
  // will be added to |unprepared_outputs_| if a PrepareCB has been specified.
  // If the size of |ready_outputs_| is less than
  // Decoder::GetMaxDecodeRequests(), the provided PrepareCB will be called for
  // the output. Once an output has been prepared by the PrepareCB it must call
  // the given OutputReadyCB with the prepared output.
  //
  // This process is structured such that only a fixed number of outputs are
  // prepared at any one time; this alleviates resource usage issues incurred by
  // the preparation process when a decoder has a burst of outputs after on
  // Decode(). For more context on why, see https://crbug.com/820167.
  using OutputReadyCB = base::OnceCallback<void(scoped_refptr<Output>)>;
  using PrepareCB =
      base::RepeatingCallback<void(scoped_refptr<Output>, OutputReadyCB)>;
  void SetPrepareCB(PrepareCB prepare_cb);

  // Indicates that we won't need to prepare outputs before |start_timestamp|,
  // so that the preparation step (which is generally expensive) can be skipped.
  void SkipPrepareUntil(base::TimeDelta start_timestamp);

  // Allows callers to register for notification of config changes; this is
  // called immediately after receiving the 'kConfigChanged' status from the
  // DemuxerStream, before any action is taken to handle the config change.
  using ConfigChangeObserverCB =
      base::RepeatingCallback<void(const DecoderConfig&)>;
  void set_config_change_observer(
      ConfigChangeObserverCB config_change_observer) {
    config_change_observer_cb_ = config_change_observer;
  }

  // Allows tests to keep track the currently selected decoder.
  using DecoderChangeObserverCB = base::RepeatingCallback<void(Decoder*)>;
  void set_decoder_change_observer_for_testing(
      DecoderChangeObserverCB decoder_change_observer_cb) {
    decoder_change_observer_cb_ = std::move(decoder_change_observer_cb);
  }

  int get_pending_buffers_size_for_testing() const {
    return pending_buffers_.size();
  }

  int get_fallback_buffers_size_for_testing() const {
    return fallback_buffers_.size();
  }

  bool is_demuxer_read_pending() const { return pending_demuxer_read_; }

  DecoderSelector<StreamType>& GetDecoderSelectorForTesting(
      util::PassKey<class VideoDecoderStreamTest>) {
    return decoder_selector_;
  }

 private:
  enum State {
    STATE_UNINITIALIZED,
    STATE_INITIALIZING,
    STATE_NORMAL,  // Includes idle, pending decoder decode/reset.
    STATE_FLUSHING_DECODER,
    STATE_REINITIALIZING_DECODER,
    STATE_END_OF_STREAM,  // End of stream reached; returns EOS on all reads.
    STATE_ERROR,
  };

  // Returns the string representation of the StreamType for logging purpose.
  std::string GetStreamTypeString();

  // Returns maximum concurrent decode requests for the current |decoder_|.
  int GetMaxDecodeRequests() const;

  // Returns the maximum number of outputs we should keep ready at any one time.
  int GetMaxReadyOutputs() const;

  // Returns true if one more decode request can be submitted to the decoder.
  bool CanDecodeMore() const;

  void SelectDecoder();

  // Called when |decoder_selector| selected the |selected_decoder|.
  // |decrypting_demuxer_stream| was also populated if a DecryptingDemuxerStream
  // is created to help decrypt the encrypted stream.
  void OnDecoderSelected(
      std::unique_ptr<Decoder> selected_decoder,
      std::unique_ptr<DecryptingDemuxerStream> decrypting_demuxer_stream);

  // Satisfy pending |read_cb_| with |status| and |output|.
  void SatisfyRead(ReadStatus status, scoped_refptr<Output> output);

  // Decodes |buffer| and returns the result via OnDecodeOutputReady().
  // Saves |buffer| into |pending_buffers_| if appropriate.
  void Decode(scoped_refptr<DecoderBuffer> buffer);

  // Performs the heavy lifting of the decode call.
  void DecodeInternal(scoped_refptr<DecoderBuffer> buffer);

  // Flushes the decoder with an EOS buffer to retrieve internally buffered
  // decoder output.
  void FlushDecoder();

  // Callback for Decoder::Decode().
  void OnDecodeDone(int buffer_size,
                    bool end_of_stream,
                    std::unique_ptr<ScopedDecodeTrace> trace_event,
                    DecodeStatus status);

  // Output callback passed to Decoder::Initialize().
  void OnDecodeOutputReady(scoped_refptr<Output> output);

  // Reads a buffer from |stream_| and returns the result via OnBufferReady().
  void ReadFromDemuxerStream();

  // Callback for DemuxerStream::Read().
  void OnBufferReady(DemuxerStream::Status status,
                     scoped_refptr<DecoderBuffer> buffer);

  void ReinitializeDecoder();

  void CompleteDecoderReinitialization(bool success);

  void ResetDecoder();
  void OnDecoderReset();

  void ClearOutputs();
  void MaybePrepareAnotherOutput();
  void OnPreparedOutputReady(scoped_refptr<Output> frame);
  void CompletePrepare(const Output* output);

  std::unique_ptr<DecoderStreamTraits<StreamType>> traits_;

  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
  MediaLog* media_log_;

  State state_;

  StatisticsCB statistics_cb_;
  InitCB init_cb_;
  WaitingCB waiting_cb_;

  ReadCB read_cb_;
  base::OnceClosure reset_cb_;

  DemuxerStream* stream_;

  CdmContext* cdm_context_;

  std::unique_ptr<Decoder> decoder_;

  // Whether |decoder_| has produced a frame yet. Reset on fallback.
  bool decoder_produced_a_frame_;

  std::unique_ptr<DecryptingDemuxerStream> decrypting_demuxer_stream_;

  // Note: Holds pointers to |traits_|, |stream_|, |decrypting_demuxer_stream_|,
  // and |cdm_context_|.
  DecoderSelector<StreamType> decoder_selector_;

  ConfigChangeObserverCB config_change_observer_cb_;
  DecoderChangeObserverCB decoder_change_observer_cb_;

  // An end-of-stream buffer has been sent for decoding, no more buffers should
  // be sent for decoding until it completes.
  // TODO(sandersd): Turn this into a State. http://crbug.com/408316
  bool decoding_eos_;

  PrepareCB prepare_cb_;
  bool preparing_output_;

  // Decoded buffers that haven't been read yet. If |prepare_cb_| has been set
  // |unprepared_outputs_| will contain buffers which haven't been prepared yet.
  // Once prepared or if preparation is not required, outputs will be put into
  // |ready_outputs_|.
  base::circular_deque<scoped_refptr<Output>> unprepared_outputs_;
  base::circular_deque<scoped_refptr<Output>> ready_outputs_;

  // Number of outstanding decode requests sent to the |decoder_|.
  int pending_decode_requests_;

  // Tracks the duration of incoming packets over time.
  MovingAverage duration_tracker_;

  // Stores buffers that might be reused if the decoder fails right after
  // Initialize().
  base::circular_deque<scoped_refptr<DecoderBuffer>> pending_buffers_;

  // Stores buffers that are guaranteed to be fed to the decoder before fetching
  // more from the demuxer stream. All buffers in this queue first were in
  // |pending_buffers_|.
  base::circular_deque<scoped_refptr<DecoderBuffer>> fallback_buffers_;

  // TODO(tguilbert): support config changes during decoder fallback, see
  // crbug.com/603713
  bool received_config_change_during_reinit_;

  // Used to track read requests; not rolled into |state_| since that is
  // overwritten in many cases.
  bool pending_demuxer_read_;

  // Timestamp after which all outputs need to be prepared.
  base::TimeDelta skip_prepare_until_timestamp_;

  // NOTE: Weak pointers must be invalidated before all other member variables.
  base::WeakPtrFactory<DecoderStream<StreamType>> weak_factory_{this};

  // Used to invalidate pending decode requests and output callbacks.
  base::WeakPtrFactory<DecoderStream<StreamType>> fallback_weak_factory_{this};

  // Used to invalidate outputs awaiting preparation. This can't use either of
  // the above factories since they are used to bind one time callbacks given
  // to decoders that may not be reinitialized after Reset().
  base::WeakPtrFactory<DecoderStream<StreamType>> prepare_weak_factory_{this};
};

template <>
bool DecoderStream<DemuxerStream::AUDIO>::CanReadWithoutStalling() const;

template <>
int DecoderStream<DemuxerStream::AUDIO>::GetMaxDecodeRequests() const;

using VideoDecoderStream = DecoderStream<DemuxerStream::VIDEO>;
using AudioDecoderStream = DecoderStream<DemuxerStream::AUDIO>;

}  // namespace media

#endif  // MEDIA_FILTERS_DECODER_STREAM_H_


Sep 01, 2017
Good intro to Bayesian Statistics. Covers the basic concepts. Workload is reasonable and quizzes/exercises are helpful. Could include more exercises and additional backgroung/future reading materials.
Oct 17, 2020
An excellent course with some good hands on exercises in both R and excel. Not for the faint of heart mathematically speaking, assumes a competent understanding of statistics and probability going in
創建者 Zhenkai S•
Oct 08, 2019
The course is in general well structured. The professor used a lot of mathematical equations to explain the contents. I have no problem understanding them. Everything goes smoothly, until the last section: Bayesian Linear Regression (BLE). In the last section, the professor skipped all the mathematics aspects and rushed the content with R / Excel examples. This is not what I expected. Overall, I will rate the course 4 stars.
創建者 Lee V•
Jul 12, 2019
The lectures were good but rattled-along at quite a speed, even with pausing and "rewinding" I still found it difficult to follow, esp towards the end. I think a short explanation at the start of the video explaining what was going to be covered, what its role was and where it fitted into the big picture might have helped (background is UK maths A-level 45yrs ago and a career on the fringes of science)
創建者 Jesse W•
May 22, 2017
I feel like I have a much better understanding of Bayesian statistics after taking this course. I learned a lot, even though it didn't take very long to get through all of the class material. My only criticism is that the 4th week seems pretty scattered. It covers a lot of different topics in not a lot of detail. Ideally, this material should be broken up into 2 weeks and covered in greater depth.
創建者 Thomas F•
Jun 29, 2017
Very good course, I may have been at a bit of a disadvantage because I came from a behavioural sciences background rather than a full statistics or math background. It was interesting though, and I think I acquired the requisite skills to conduct a Bayesian analysis in future. However, at some points in the class it does become very formula heavy, which I did find tough to grasp at some points.
創建者 Arasch M•
Jul 07, 2019
The course helps in developing a quite sound grasp of the Bayesian approach to the world. The assignments are feasible and help in gaining a deeper understanding of each subject. However there is a caveat: You definitely need to review your math skills before starting this course (esp. calculus, arithmetics and combinatorics) otherwise you'll be struggling with the particularities !
創建者 Joshua A•
Sep 04, 2017
Excellent introduction to Bayesian statistics. More proofs would have been nice (perhaps an optional advanced material section?). The later half of the course increases quite a bit in difficulty and could use 1-2 more examples + applications. Professor did a great job and the quizzes thoroughly tested my knowledge. Overall, I would definitely recommend this course.
創建者 Diogo P•
Jul 19, 2017
Great lectures. The explanation of each topic is extremely clear and avoids excessive mathematical burden. Lectures are short and concise. Quizzes or at least Module Honors could be a bit more challenging, though. It's a great course, anyway. I'll be looking forward to enroll in the next course of the sequence, entitled "Bayesian Statistics: Techniques and Models".
創建者 Francisco A d A e L•
Nov 30, 2016
Very good course, with less emphasis in the videos and more on exercises and critical thinking, the way I like and learn the best. I particularly liked that the lecturer writes on a transparent vertical surface standing between him and the camera, very convenient. For those not so familiar with mathematics, this might hurt a bit but the payoff is super positive.
創建者 George K•
Jul 30, 2019
Really enjoyed the course! Thank you. I would have given a higher rating if: 1) the instructor had spend more time on the intuition underpinning different derivations, 2) provided more context, 3) discussed more examples from practice. However, I am definitely continuing on to "Bayesian Statistics: Techniques and Models"! Thank you once more, team UCSC!
創建者 Anderson F•
Apr 13, 2020
I enjoyed the course. I was looking for a way to improve my knowledge of statistics and bayesian maths. I mainly used excel for the calculations. I would appreciate an additional tutorial on plotting mass and PDF function etc against Theta and real world variables to explore impact of parameters on distribution shape on prior and posterior results.
創建者 Tim B•
May 27, 2020
Exceptionally interesting class. Professor was knowledgeable and engaging. The key insight was to approach the "quizzes" as homework, a learning process. Some of the lectures were of variable audiovisual quality and the pacing of some sections was not uniform, but overall, a triumph. More from this professor please! Fun.
創建者 Florian M•
Mar 02, 2018
Herbert Lee is great at explaining the mathematics behind Bayesian statistics. However, I think the course can improve greatly by also focusing more on context and the intuition behind the mathematics. I often found that I was able to pass all quizzes, while I did not 100% understand why I was doing what I was doing.
創建者 JAY C•
Jun 12, 2020
Great discussion into the ideas. The quizzes are relevant to the lectures as well and pretty straightforward, you don't need to go outside of the lecture itself to be able to do the quizzes. the only thing would be it would be good if the lectures notes were in print as Prof. Lee's writing is sometimes hard to read.
創建者 Ali Z•
Nov 22, 2016
As a grad student myself, I liked the way this course was presented in short video format and in only 4 weeks. Definitely there are much more to learn about Bayesian Statistics and one can go way deeper, but this course gives the required basic Bayesian knowledge to someone who wants to get familiar in a short time.
創建者 Aditya D•
Jul 17, 2019
The course itself is well structured and covers a lot of material.
There are points in the course where the order of reading material and videos needs to be switched. Also, it would help to update some videos with a little more explanation. It appears as if the lecturer is skipping steps.
創建者 Marc D•
Jan 26, 2019
I liked it as introduction to Baysian statistics. With the material provided it was quite easily possible to answer the questions. I would have preferred that the videos of the course contained all the material and that it would not have been required to have read through material.
創建者 Thierry C•
Oct 01, 2019
The course was well explained and there were several exercises pushing the learner to understand the logic behind the mathematical concept. I think it is a suitable class for people with already a certain level of statistics knowledge, even though all concepts are well explained.
創建者 Jose N d l R•
Apr 17, 2017
I think that, besides lesson 11 and 12, everything was very well explained. I was a bit confused with lessons 11 and 12 since I am not new to econometrics. Perhaps I found it confusing the theory background related to the lessons themselves. Just my opinion, very good course.
創建者 Praveen K•
Jun 01, 2020
The course was very well designed, I got to learn about a lot of new things in statistics that I had to understand. But for a Data Analyst working on large data sets and primarily working on ML this course is far too basic. Also, some of the concepts can be explained better.
創建者 Łukasz F•
Feb 05, 2019
I really liked the course.
What I think could be nice improvement would be more nsightful notes. Which means, that after every video, there should be a separate sheet with all the formulas being described in more detail, so that you can refer to them any time during quizes.
創建者 Thomas J M•
May 22, 2018
Overall the course is pretty good. They breakdown the concepts into clear and concise lectures. My only grip, is that the quizzes occur a little too frequently. They really interrupt the flow of the class. I would definitely prefer them spaced in 30-60 minute interval.
創建者 Ekaterini T•
Oct 31, 2018
I found the need to search for most of the material needed to understand the lessons in other sources. Other than than it was a relatively easy class, which covers nearly the basics. This is not a tutorial on Data Analysis on R, although a short introduction is provided.
創建者 Mohd S K•
Nov 19, 2019
Course covers the concept in a very simple way. Examples and assignments are very good.
However some of the statements made throughout the lectures needs more explanation , the course did not dedicate any videos to get familiar with terminology related to probability.
創建者 Luiz G S S•
Apr 17, 2020
It is a really interesting course. However, I think it should include more examples and meaningful ways to estimates some parameters. For example, how can I estimate alpha and beta for an Inverse-Gamma distribution in order to obtain a prior for the sigma-squared?
Jan 14, 2017
Pen hard to see against shirt. Was mildly irritating to wait for prof to write out stuff, maybe prewrite it?
Went too fast forward for me, would've liked complementary optional material, eg extra quizzes, to help understand and get used to the tougher parts.


Survey of Web Browsers for Windows Mobile – Windows Mobile Team Blog - Browser on q9h sucks
- Views: 886 369
The more you use a browser, the more you bog it down. Which is why you should never trust that new browser smell: every browser sucks. We now have one less browser engine, and a last man standing (Firefox) in deep trouble (reasons below). If you agree that this sucks, install.


Thanks to the courtesy of Mr. Tomasz Kozar who collaborates with our project we received an invitation to the Microsoft headquarters in Warsaw. It was an enriching experience. Our work went according to the agenda.
Our friend Kacper Jańczuk was a speaker during a conference at the Polish-Japanese Academy of Computer Technics which was organized by the Institute of Informatics Education and Computer Application in Warsaw (http://mrozy.net/). The presentation during the conference was aimed at showing the princpiles and teachers of other schools how can interesting interdisciplinary projects with the use of modern technologies be realized. We were presenting the 3-SAT project.


Becoming a data analyst ain’t a walk in the park, but mastering the basics is key. Learn data types, statistical measures, and data visualization. Excel or Google Sheets are your go-to tools, with functions and pivot tables ruling the game. Dive into SQL, Python, or R for
- Learn the basics of data analysis to build a strong foundation.
- Master spreadsheet tools like Excel or Google Sheets for data manipulation.
- Explore data analysis tools like SQL, Python, or R for advanced skills.


my dismay I found out that the photos looked very well in Sam's
laptop, while in my PC, absolutelly dark. I am giving you two choices
hopes that one site will look well on your monitor.
each site has two pages to confuse things more. You have to return
here to make a new choice of site.
you know how to download an image? on the enlarged image window, right
click, or option-click the image and chose to save or download the


/**********************************************************************
 * Copyright (c), 1991-2013, T&W ELECTRONICS(SHENTHEN) Co., Ltd.
 * MT7620 Buttons driver
**********************************************************************/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/version.h>
#include <linux/signal.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/resource.h>
#include <linux/timer.h>
#include <linux/sched.h>
#include <linux/net.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <asm/types.h>
#include <asm/irq.h>
#include <asm/mach-ralink/surfboardint.h>
#include "../../../vendor/triductor/triapi/tri_ctl.h"
#include "../../../vendor/triductor/triapi/tri_para.h"
#include <gpio.h>
#include <btn.h>

extern struct btn_dev btn_table[];           /* Defined in product.c */
extern struct btn_cfg btn_config[];          /* Defined in product.c */
extern gpio_level *btn_level;

static gpio_level btn_level_table[4];

extern int g2_ctrl_xmit(struct g2_ctrl_msg *ctrl, size_t len);

static void gpio_interrupt_ctrl(struct btn_dev *dev, unsigned char enable)
{
	unsigned char edge = IRQF_TRIGGER_NONE;

	if(enable) {
		if(GPIO_LEVEL_HIGH == dev->level) {/* Trigger at rising edge */
			edge = IRQF_TRIGGER_RISING;
		} else {/* Trigger at falling edge */
			edge = IRQF_TRIGGER_FALLING;
		}
	}
	gpio_set_edge(dev->gpio, edge);
}

static irqreturn_t button_irq_handler(int irq, void *dev_id)
{
    struct btn_dev *dev = NULL;
	int i;

    for(i = 0; btn_table[i].gpio != GPIO_END; i++) {
		dev = &btn_table[i];
		if(gpio_get_ins(dev->gpio)) {/* Read IRQ status and make it clean */
			if(BTN_STATE_IDLE == dev->cur_state) {
				dev->int_ctrl(dev, 0);/* Disable IRQ first */
				mod_timer(&dev->timer, jiffies + msecs_to_jiffies(DELAY_TIME));
			}
		}
    }

    return IRQ_HANDLED;
}

static int mt7620_btn_state_read(struct btn_dev *dev)
{
	int ret_val = 0;
	if(dev->gpio < GPIO73) {
		ret_val = gpio_read(dev->gpio);
	} else {
		ret_val = btn_level[dev->gpio - GPIO95];
	}
	return ret_val;
}

static int __init mt7620_btn_init(void)
{
	struct btn_dev *dev = NULL;
	struct btn_cfg *cfg = NULL;
	struct g2_ctrl_msg msg;
	int i, j, ret_val = -EFAULT;

	ret_val = btn_core_init();
	if(ret_val < 0) {
		goto out;
	}
	for(i = 0; btn_table[i].gpio != GPIO_END; i++) {
		dev = &btn_table[i];
		for(j = 0; btn_config[j].act != BTN_MSG_END; j++) {/* Get the maximum active time for each button device */
			cfg = &btn_config[j];
			if((cfg->mem1 == dev->gpio) && (cfg->t1_max > dev->t_max)) {
				dev->t_max = cfg->t1_max;
			}
			if((cfg->mem2 == dev->gpio) && (cfg->t2_max > dev->t_max)) {
				dev->t_max = cfg->t2_max;
			}
			if((cfg->mem3 == dev->gpio) && (cfg->t3_max > dev->t_max)) {
				dev->t_max = cfg->t3_max;
			}
		}
		dev->btn_read = mt7620_btn_state_read;
		dev->cur_state = BTN_STATE_IDLE;/* Button's state initializing */
		setup_timer(&dev->timer, button_timer_handler, (unsigned long)dev);/* Button event validation timer */
		if(dev->gpio < GPIO73) {
			dev->int_ctrl = gpio_interrupt_ctrl;
			gpio_config(dev->gpio, GPIO_IN);/* Buttons should be working at GPIO input mode */
			dev->int_ctrl(dev, 1);/* Enable IRQ */
		}
	}
	ret_val = request_irq(SURFBOARDINT_GPIO, button_irq_handler, IRQF_SHARED, "Button", dev);
	if(ret_val != 0) {
		printk(KERN_ERR "unable to request IRQ for GPIO (error %d)\n", ret_val);
	} else {
		printk("TBS button driver for %s initialized, IRQ=%d\n", PRODUCT, SURFBOARDINT_GPIO);
	}
	for(i = 0; i < (sizeof(btn_level_table) / sizeof(gpio_level)); i++) {
		btn_level_table[i] = GPIO_LEVEL_HIGH;
	}
	btn_level = &btn_level_table[0];
	msg.hdr.type = CTL_PKT_TYPE_SET_VAL_REQUEST;
	msg.hdr.length = htons(sizeof(unsigned int) * 3);
	msg.hdr.seq = htons(net_random() & 0xFFFF);
	msg.code = htonl(PARA_CODE_GPIO_DIR);
	msg.mask = htonl(0x00c00f80);
	msg.value = htonl(0x00c00000);
	ret_val = g2_ctrl_xmit((unsigned char *)&msg, sizeof(struct g2_ctrl_msg));

out:
	return ret_val;
}

static void __exit mt7620_btn_exit(void)
{
	struct btn_dev *dev = NULL;
	int i;

	for(i=0;btn_table[i].gpio != GPIO_END; i++) {
		dev = &btn_table[i];
		if(NULL != dev->int_ctrl) {
			dev->int_ctrl(dev, IRQF_TRIGGER_NONE);/* Disable IRQ */
		}
		dev->cur_state = BTN_STATE_IDLE;
		del_timer_sync(&dev->timer);
		dev->int_ctrl = NULL;
		dev->btn_read = NULL;
	}
	free_irq(SURFBOARDINT_GPIO, dev);
	btn_level = NULL;
	btn_core_exit();
}

module_init(mt7620_btn_init);
module_exit(mt7620_btn_exit);

MODULE_AUTHOR("XiaChaoRen");
MODULE_DESCRIPTION("MT7620 buttons driver");
MODULE_LICENSE("GPL");


Downgrading website management subscriptions means losing access to premium speed and security optimization services. If you move forward with the downgrade, just make sure these are things you're prepared to handle yourself!
You can upgrade, downgrade or cancel your website management subscription(s) anytime by:
- emailing our support team the request directly
- submitting your upgrade/downgrade request through our ticket dashboard.
You can upgrade, downgrade or cancel website management subscriptions for your clients anytime by following the instructions here.
- 👨💻 Sign up for your WP Buffs website management subscription(s)
- 📆 Schedule your private, 1-on-1 discovery call (required for white-label partners)
- ✔ Complete our care plan questionnaire (see which plans are the best fit for you)
- 👻 Learn more about our White Label service


Headered SNES roms used to be the norm in the late 90's, since back then ROM copiers actually used them for something (storing ROM type, mapping etc.). So the rule of thumb is that if a patch is very old and there are no specific instructions, there's a good change it needs a headered ROM. This also applies to the early 00's.
Incidentally, I remember a tool which allowed you to tweak patches themselves to work with headerless ROMs, but can't find it at the moment.
Maybe this is the one? it worked for me in cases the patch asked for a headered rom, but I wanted to apply other patches that didn't and it became a real mess, so removing the header from the patches themselves was the only way to solve it.


Experience from writing trace_inputs.py
maruel at chromium.org
Fri Mar 21 14:49:55 UTC 2014
We got a race conditions with our emails, sorry for the duplicated arguments.
In short, we are in agreement.
2014-03-21 9:43 GMT-04:00 Philippe Ombredanne <pombredanne at nexb.com>:
> In your case using the standard Python shlex module may be of some help?
Eh, definitely a lack of knowledge on my part as I didn't know about
shlex. I would have saved some work there.
> Indeed in newer strace versions some things may either have been fixed
> or there are new features that could help alleviate some of your
> You might be using 4.5.20: a goodie but oldie.
> For instance it does not have the important --in your case-- -y option
> for absolute file descriptor paths decoding.
Yes I'm on 4.5.20. I mildly recall hitting problems when trying to
compile strace's tip of tree since I think (?) it required a newer gcc
version than the stock one (4.6.3) in 12.04. That was in 2012. At that
point, I wanted the tool to be usable as is for devs so I decided
against requiring a newer version.
>> In practice, I stumbled upon a lot of issues while reading the logs;
>> - Processes being killed arbitrarily, causing all sorts of incomplete logs.
>> The chromium unit tests tends to open a lot of processes quickly and kill
>> them just for fun.
> In general using -f may yield some weirdness.
> My experience is that -ff works great even in these cases.
> If you found some bugs there, please drop a mail here!
I'd have to reproduce using latest strace version. If I do, I'll report back.
>> - Even using one log file per process with -ff still cause occasional
>> corrupted log file on heavily multithreaded processes. Note that using a
>> workstation will a lots of core may probably help exhibit this problem more.
> ... using -ff is a better way to trace multiple threads and processes correctly.
> I am using it on very large trace with 4.8 and HEAD without much of a
> bad behavior (by large I mean 300 to 500K processes and 20 to 30 GB
> strace outputs).
> If you see some issues that can be reproduced, please drop a mail here
> so someone can investigate.
That's larger than what I traced, usually <1gb and a few hundreds of processes.
>> - No clear separation of call / return in the logs, causing a funny search
>> to figure out which call completed. There's an heuristic in
> There are no unfinished/resumed calls when using -ff. So IMHO you
> should be using -ff -tt/ttt and then reassemble the per-process traces
> in one big file that you can then stream parse line by line. Using the
> strace-log-merge util will do this for you (this is in Perl and if
> this is an issue this would be easy enough to write that in Python).
> The calls will be in the right sequence and each line will have a pid.
> This approach is used in strace tests itself : see  for a tiny
> shell script example.
I definitely recall seeing unfinished/resumed calls when using -ff, at
least on 4.5.20. If I reproduce on newer version, will report back.
Thanks, I didn't know about strace-log-merge.
>> - Encoding, since linux doesn't prescribe utf-8, I have to hope for the
>> best. Note: I should use -x, I don't recall why I had commented it out.
>> Maybe just laziness.
> Do you have an example of a problematic output?
> FWIW, the approach taken by rsync with file paths listing is the following:
> - try to decode paths using the locale/file system encoding (possibly utf-8)
> - if this fail, encode failing characters in octal
> - alternatively force utf-8 with an option and fail if decoding cannot be done
> Strace has a similar logic with -x alright, except it tries only ASCII
> decoding and falls back to hex.
> IMHO that should work out well for a json structured output.
> Why did you drop using -x?
Didn't drop, just hadn't started using it. I don't recall why; it's
been almost 2 years since I effectively touched this code. In
practice, it was not necessary for my end goal. Writing
trace_inputs.py was just a mean to achieve what I wanted to do
(identify all run time dependencies), not a goal in itself. So that's
why it has a very limited feature set.
>> - Only after the process hierarchy is figured out I could figure out the
>> starting current working directory of each process, causing a lot of "late
>> bound path". See RelativePath class. It definitely slows down reading the
>> logs and adds potential corruption of the paths in the trace reader if it
>> incorrectly guessed the starting cwd.
> This is an issue indeed. YMMV, but in your case (i.e. Ubuntu) where
> most exe have likely been compiled with a GNU toolchain you would end
> up having typically a getcwd syscall early on in most processes and
> typically in the first one.
FTR, the chromium unit tests usually fork and start working right away
instead of exec'ing, so most processes didn't log an initial getcwd().
But yes -y would have saved me a lot of work.
>> - No header to list the hooked functions I should expect to appear, and the
>> number of arguments in each. Since it changes from OS version to another, I
>> made the code assert on unknown function so I can add them manually.
> Good point: someone (Mike F./vapier?) suggested we should return some
> directory of supported calls and calls specs. How would you see such
> an output structure to be useful?
In general the reader has to know what it is looking for, so it's not
that much of a big deal. But I think it'd be generally interesting.
>> - Variable number of arguments to a function coupled with split log lines
>> and interesting quoting caused some headaches IIRC. (Or was it OSX doing
>> this? Sorry I don't recall)
> If you are talking about suspend/resume, then using -ff takes that away.
> As for varargs --if this happens-- I guess this is the way the
> syscalls are. Not much that can be done.
> To the best of my knowledge quoting in strace is rather consistent,
> but they are surely some gremlins left and right.
> Do you have an example of this?
Actually, I think I misremembered and it was indeed an issue with
dtrace (sorry for the confusion). For the varargs, for example open()
accepts either 2 or 3 arguments but the code is handling it just fine.
It's just a fact of life and the reader has to live with it. I should
have skipped this comment.
>> Of all the problems, the log corruption with heavily multithreaded process
>> on a multi-core system has been the most problematic. Everything else is
>> solvable but when the log is corrupted, there isn't much to do. Last time I
>> tried, which is a long long time ago, I was still able to reproduce
>> occasional corruptions with our test named "browser_tests".
> Please send a note here with details. I am using strace routinely to
> trace execution of 300K+ processes at once and have not seen a bad
> behavior to date. Also please consider checking out 4.8 or HEAD.
I didn't keep any broken log and never trace nowadays. Will report
with one if I reproduce again with a newer version.
>> A separate issue I got was that I was not able to trace native client
>> sandboxed unit test processes unless strace was running under sudo but to do
>> that I need to attach to the already started process to be able to not run
>> the unit test itself as root. It's been a pain to implement. Note strictly
>> strace's fault, just FYI.
> Is this "native client" of yours using some setuid/setgid? If so,
> there are known limitations since strace uses the ptrace syscall an
> inherits from its limitations which are about security. This is more
> or less explained in the man (2) ptrace and man (1) strace though this
> is an area that has never been quite clear to me. Have your tried if
> the -u option could be of any help to you?
Native Client = https://code.google.com/p/nativeclient/
I didn't use -u, I should have. It would have been simpler. Again,
lack of knowledge (or properly reading the man page, I naively assumed
this functionality wasn't there).
>> What I'd recommend;
>> - json is good for smallish document but is not great for unbounded
>> documents. Logs can get >2gb. IMHO, I'm not sure it's a good fit.
> What about if a trace is not ONE json doc, but instead MANY?
We agree on this, I explained it more in a separate email.
>> Something custom would be fine with me. Just expose a reference code to read
>> it back in 1 language, 2-3 popular languages if possible.
> Once we start to have a more or less working feature, would you be
> willing to chip in? Like a possible Python reference code?
I can't promise anything currently but the format I proposed in the
other email would be parseable in a relatively short amount of code.
We'll see in time. :)
> About the cwd, see above: adding absolute paths everywhere makes the
> cwd possibly a non issue. That said, the pid, ppid and cwd should
> eventually be data attached to every call in a structured output, even
> if this is a bit redundant.
FTR, I think it's simpler (IMHO) to only record what was called and
have the reader reconstruct it. In particular, to not make the
structured output too configurable. This makes the reader code
simpler, since there's less code paths. More options = more file
formats = more reader code paths = less tested code. That's my humble
opinion, feel free to ignore. My preference is to have one canonical
way to print it out that is dense enough but has all the required
information to read it deterministically, and that's it.
> If you were to encode this by hand in json, how would you structure this?
> Also I wonder if attaching some arbitrary unique id to every call
> could help reassemble multiple entries sanely.
Wrote example in the other thread.
> I guess the strace maintainers should take this as a compliment :P
It is. :)
More information about the Strace-devel


Multi-scale modelling of spatial and spatio-temporal patterns in biological developments.
We study the dynamics of the developmental patterns on a variety of domains, from tissue formation to animal coats. To be more specific, we model the developmental patterns in an integrated environment of molecular-level regulatory interactions and cellular-level activities, including mitosis, cell differentiation, cell migration and apoptosis. Our latest biological validation is on Drosophila's eye formation.Student:
- Hien Nguyen
- Integrated Cellular and Gene Interaction Model for Cell Migration in Embryonic Development, Proceedings of IDASB (workshop on Integrative Data Analysis in Systems Biology at BIBM2010)
- Integrated cellular and gene interaction modeling of pattern formation in Interational Journal of Computational Biology and Drug Design vol. 4, no. 4, pages 361-372
A computational modeling framework for gene regulatory networks based on insufficient data
Deals with developing statistical modeling on gene regulatory networksStudents:
- Yang Zhang
- Zhengyu Ouyang
CDAO-store is a repository providing a rich set of API's for querying and visualizing phyloinformatics data.Students:
- Brandon Chisham
- Trung Le
- Ben Wright
- iEvoBio2010 [Abstract]
- CDAO-Store: Ontology-driven Data Integration for Phylogenetic Analysis in BMC Bioinformatics 2011, 12:98
Have a research project not listed here? Send any information you want posted here.


Some time ago Homer lived in a beautiful city. There were $$$n$$$ blocks numbered from $$$1$$$ to $$$n$$$ and $$$m$$$ directed roads between them. Each road had a positive length, and each road went from the block with the smaller index to the block with the larger index. For every two (different) blocks, there was at most one road between them.

Homer discovered that for some two numbers $$$L$$$ and $$$R$$$ the city was $$$(L, R)$$$-continuous.

The city is said to be $$$(L, R)$$$-continuous, if

1. all paths from block $$$1$$$ to block $$$n$$$ are of length between $$$L$$$ and $$$R$$$ (inclusive); and
2. for every $$$L \leq d \leq R$$$, there is exactly one path from block $$$1$$$ to block $$$n$$$ whose length is $$$d$$$.

A path from block $$$u$$$ to block $$$v$$$ is a sequence $$$u = x_0 \to x_1 \to x_2 \to \dots \to x_k = v$$$, where there is a road from block $$$x_{i-1}$$$ to block $$$x_{i}$$$ for every $$$1 \leq i \leq k$$$. The length of a path is the sum of lengths over all roads in the path. Two paths $$$x_0 \to x_1 \to \dots \to x_k$$$ and $$$y_0 \to y_1 \to \dots \to y_l$$$ are different, if $$$k \neq l$$$ or $$$x_i \neq y_i$$$ for some $$$0 \leq i \leq \min\{k, l\}$$$.

After moving to another city, Homer only remembers the two special numbers $$$L$$$ and $$$R$$$ but forgets the numbers $$$n$$$ and $$$m$$$ of blocks and roads, respectively, and how blocks are connected by roads. However, he believes the number of blocks should be no larger than $$$32$$$ (because the city was small).

As the best friend of Homer, please tell him whether it is possible to find a $$$(L, R)$$$-continuous city or not.


Defender of the Crown was a troubled production. As the deadline was approaching and the initial development team fell more and more behind schedule, not only some features were removed from the baseline (which re-appeared in later ports), but also some essential changes were made to the basic game mechanics. One of them was the switch from real time to turn-based. Although Cinemaware later released a not dissimilar game (Lords of the Rising Sun) which did sport real time gameplay, they never re-visited their initial genre-defining classic in this respect. So somebody else did it instead. Enter Joan of Arc.


Im offering my services of Gaming Servers setup and/or Administration. My speciality is in Red Hat 9, but can do most linux Operating Systems.
I have set up games such as Steam Based games (counterstrike, Natural Selection, etc..), Return to Castle Wolfenstein (+ standalone Et Mod), and many other games.
For server setup you can hire me per hour (several server setups) or a one off fee for a server Administration is an hourly payment. If i fail to setup the server, you get your money back.
I have previously worked for WebspaceUK and was the Gaming Server Administrator, which meant i looked after the server and did everything to do with it (minor FTP tasks, set up services etc). If you would like to hear the owner's testimonial please contact me.
So, if you are interested in hiring me or finding out more information please contact me here: [email protected] or add me on [msn] cartoonwally[at]hotmail[dot]com
Last edited by Matt -Seeksadmin; 05-22-2004 at 09:19 AM.


I’m using the latest version of Psi4 (1.4a1.dev60) on Fedora 28/29 and encountered the problem with segmentation fault. Here is some input:
H 0.14748 -1.86719 0.82318
N 0.22937 -0.87127 0.58052
O 0.68847 -0.78564 -0.71211
O -0.64741 -0.08013 0.99612
N -0.23139 1.69102 -0.83138
H -1.25902 1.75249 -0.85594
H 0.25985 1.10119 -0.80404
H 0.02703 2.29628 -0.03930
It reproduced with every methods (DFT, MP2, OMP2, CCSD, SCF) and basis sets (cc-pvdz, sto-3g, 6-31g). I guess, the problem is analytic gradients. It is always stops at SCF GRAD module. With dertype='energy' the routine works clear.
Any chance there’s an ubuntu or conda libint package around such that the build-time libint could be different from the runtime-loaded libint? If those two are built with different max AM, a runtime segfault is what happens. peripherally-relevant post
I can’t find a specific directly, but I’m confident psi has built and at least quick-tested with a GCC 8.


I love early access games. Sure, they’re a risky investment. Sometimes it would be more efficient to throw my money directly into the nearest trash can. They promise a lot of things that will never come into fruition. The game I dream up might be entirely a different game than the one the developers are dreaming. And I might not like the game they’re making. The developers could be lazy bums that don’t know how to make games and come to dislike making games. Oftentimes, the game might never come out. It might fizzle away after a year or so of work; the victim of foolish spending and incompetence in video game development. But I find that, most of the time, it’s worth the risk.
A lot of people that know me will know that I am a big supporter of Star Citizen. For me, Star Citizen is the quintessential early access game: Chris Roberts, maker of the classic Wing Commander games, had a dream. His dream was to make the best space simulation out there. He wanted to make not just a space flight sim, though, he wanted to make a first-person universe. A universe where you can walk around in your ship, take off, fly to another planet, land, get out of your ship, walk to a store front, buy a load of lucrative cargo, load it into your cargo hold, take off, jump to another sector of the galaxy, and sell your cargo at a space station that is also fully explorable on foot. A universe populated with thousands of NPCs and other players. I heard about Star Citizen and instantly started dreaming along with Chris Roberts and his team.
So where am I going with this? I want to focus gameSLRP on early access games. This isn’t to say we won’t talk about big AAA titles or what’s going on in the Sony and Microsoft world, but that won’t be our focus. I want to start showing you guys some of the games that some these small devs have been dreaming up. And I want you to start dreaming with them.


//
//  DXGetSpcSumReallyModel.h
//  DXQ
//
//  Created by rason on 8/13/15.
//  Copyright (c) 2015 rason. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface DXGetSpcSumReallyModel : NSObject

@property (nonatomic, copy) NSString *L_COLLECT;

@property (nonatomic, copy) NSString *L_PRAISE;

@property (nonatomic, copy) NSString *L_COMMENT_SUM;

@property (nonatomic, copy) NSString *L_SHARE;

@end


Food for /θɔt/ or /θɑt/?
A Case Study of a Low Back Vowel Merger
The English low back vowel merger, where words like caught and cot are pronounced identically, is a well-studied phenomenon. Generally, these studies focus on mergers within given regions, comparing vowels of non-mobile individuals. My research differs in exploring the effects of relocation. I examine pronunciation differences of vowels in differently gendered twins from England who moved to Canada as children. Despite growing up in similar environments, their vowel patterns differ: there is some evidence of merger in the female’s but not the male’s vowels. This suggests that mobility and exposure to a new dialect may affect pronunciation changes but are not the sole factors.
This work is licensed under a Creative Commons Attribution 4.0 International License.
This is an Open Access journal. All material is licensed under a Creative Commons Attribution 4.0 International (CC BY 4.0) licence, unless otherwise stated.
Please read our Open Access, Copyright and Permissions policies for more information.


Guido's keynote slides from PyCon 2013: https://www.dropbox.com/s/xknbe58zcvjhzhv/PyCon2013.pptx
HN comments: https://news.ycombinator.com/item?id=5395385
IMO, it's about fracking time asyncore got replaced with something half-decent; I've been writing I/O event loops inside threads for way too long (I probably should have been using Tornado or eventlet, but still...). The API looks kinda eclectic (which I guess it would have to be, if it is to work with the multitude of existing solutions), but I'm sure they'll tighten it by the time they release. This is definitely a Good Thing. For me, this is the first real incentive to switch to Python 3.


BigData Inc. is a corporation that has n data centers indexed from 1 to n that are located all over the world. These data centers provide storage for client data (you can figure out that client data is really big!).

Main feature of services offered by BigData Inc. is the access availability guarantee even under the circumstances of any data center having an outage. Such a guarantee is ensured by using the two-way replication. Two-way replication is such an approach for data storage that any piece of data is represented by two identical copies that are stored in two different data centers.

For each of m company clients, let us denote indices of two different data centers storing this client data as ci, 1 and ci, 2.

In order to keep data centers operational and safe, the software running on data center computers is being updated regularly. Release cycle of BigData Inc. is one day meaning that the new version of software is being deployed to the data center computers each day.

Data center software update is a non-trivial long process, that is why there is a special hour-long time frame that is dedicated for data center maintenance. During the maintenance period, data center computers are installing software updates, and thus they may be unavailable. Consider the day to be exactly h hours long. For each data center there is an integer uj (0 ≤ uj ≤ h - 1) defining the index of an hour of day, such that during this hour data center j is unavailable due to maintenance.

Summing up everything above, the condition uci, 1 ≠ uci, 2 should hold for each client, or otherwise his data may be unaccessible while data centers that store it are under maintenance.

Due to occasional timezone change in different cities all over the world, the maintenance time in some of the data centers may change by one hour sometimes. Company should be prepared for such situation, that is why they decided to conduct an experiment, choosing some non-empty subset of data centers, and shifting the maintenance time for them by an hour later (i.e. if uj = h - 1, then the new maintenance hour would become 0, otherwise it would become uj + 1). Nonetheless, such an experiment should not break the accessibility guarantees, meaning that data of any client should be still available during any hour of a day after the data center maintenance times are changed.

Such an experiment would provide useful insights, but changing update time is quite an expensive procedure, that is why the company asked you to find out the minimum number of data centers that have to be included in an experiment in order to keep the data accessibility guarantees.


You are given a string $$$s$$$, consisting of $$$n$$$ letters, each letter is either 'a' or 'b'. The letters in the string are numbered from $$$1$$$ to $$$n$$$.

$$$s[l; r]$$$ is a continuous substring of letters from index $$$l$$$ to $$$r$$$ of the string inclusive.

A string is called balanced if the number of letters 'a' in it is equal to the number of letters 'b'. For example, strings "baba" and "aabbab" are balanced and strings "aaab" and "b" are not.

Find any non-empty balanced substring $$$s[l; r]$$$ of string $$$s$$$. Print its $$$l$$$ and $$$r$$$ ($$$1 \le l \le r \le n$$$). If there is no such substring, then print $$$-1$$$ $$$-1$$$.


JRA-55C is a fixed observing system atmospheric reanalysis that uses the same model and data assimilation scheme as JRA-55. The observations assimilated include surface station data, radiosondes, tropical cyclone retrievals and wind profilers. No satellite observations are included. JRA-55C spans November, 1972 thru December, 2012 but may be extended back to 1958 by combing it with JRA-55 for the pre-satellite era 1958- October 1972. JRA-55C is intended for detecting the impacts of observing system changes on JRA-55, and for studies of climate variability and change.
The following was contributed by Chiaki Kobayashi, Japan Meterological Agency and Meterological Research Institute, December, 2015:
The Japanese 55-year Reanalysis Conventional (JRA-55C; C. Kobayashi et al. 2014) is an atmospheric reanalysis assimilating conventional observations only. This reanalysis dataset was created without assimilating satellite observations by using the same data assimilation system as JRA-55 (S. Kobayashi et al. 2015) in order to investigate the impact of observing system changes on the JRA-55 product and to provide more homogeneous meteorological variables for studies of climate change and multi-decadal variability. The conventional observations assimilated here are surface observations, radiosondes, tropical cyclone retrievals and wind-profilers. The JRA-55C reanalysis covers the period from January 1958 to December 2012, including the pre-satellite era (January 1958 to October 1972) from the JRA-55 reanalysis; the data assimilation of JRA-55C was performed only for the period after November 1972 during which satellite observations were assimilated in JRA-55.
Along with these key limitations, the product has large uncertainties in areas where conventional observations are sparse, e.g. over oceans, in the Southern Hemisphere high latitudes and in the upper stratosphere.
There are large uncertainties in model diagnostic variables such as precipitation, evaporation, radiation flux and cloud cover. This is the case with all reanalyses, (see Expert Guidance of JRA -55).
The bias correction method for radiosonde temperatures adopted by JRA-55 is applied to JRA-55C (see Subsection 2.2.a in S. Kobayashi et al., 2015).##
Click the thumbnails to view larger sizes
|Time series of the RMSE of 2-day forecasts of geopotential height at 500 hPa verified against the corresponding analysis for the NH (20°N−90°N). Units are geopotential meters (gpm). A 12-month running mean was applied for smoothing. “Operation” indicates the JMA operational forecast started from the JMA operational analysis at the indicated time. Each forecast is started from the data produced by the corresponding reanalysis. Adapted and updated from C. Kobayashi et al. (2014, Fig. 3) (Contributed by C. Kobayashi)|
|Time-height cross section of equatorial (5°S−5°N) zonal mean U wind component from 1958 to 2012 shown in a) JRA-55, b) JRA-55C and c) JRA-55AMIP (Atmospheric Model Intercomparison Project (AMIP)-type simulation using the same numerical weather prediction system as JRA-55 without assimilating observations). Units are m s−1. Adapted and updated from C. Kobayashi et al. (2014, Fig. 7) (Contributed by C. Kobayahshi)|
Kobayashi, Chiaki & National Center for Atmospheric Research Staff (Eds). Last modified 02 Mar 2016. "The Climate Data Guide: JRA-55C (reanalysis using conventional observations)." Retrieved from https://climatedataguide.ucar.edu/climate-data/jra-55c-reanalysis-using-conventional-observations.


Rewards, once created, can be assigned to achievements. Upon earning an achievement, you can then distribute these rewards to the player. They can be anything you like. You might want to award a certain number of points to a custom leaderboard. You might want to fire off an order to Amazon for a gift card. You might send an email to someone in HR to hand-deliver a weekend getaway package. The possibilities are endless.
Rewards have the following properties:
Click here for information about common properties.
Rewards can be anything you like, but it's your responsibility to to distribute the reward to the player.


Mlc 3.0 Developped For 86
Posted 24 May 2006 - 11:53 PM
NOTE: I am not contributing in this project anymore atm, since I don't know ASM, I just wanted to let you know that there was still a MLC being developped on TI calcs and I'm not sure what the new author is planning
EDIT: btw I posted a link to the topic Deimos posted on EPS forums today on Omnimaga that linked to MLC discussion here
Posted 25 May 2006 - 01:33 PM
Posted 25 May 2006 - 11:29 PM
Posted 23 September 2006 - 08:53 PM
Also, I've made an MLC website:
There is a MLC Casio AFX page, so if you have any information about MLC for the Casio AFX that you'd like to share, just post it here, and I'll hopefully remember to check this forum again and then update the website .
Posted 24 September 2006 - 01:09 PM
Posted 25 September 2006 - 12:13 AM
Posted 26 September 2006 - 04:41 PM
multi platform language...
in which language do you intend to write the mlc? (asm,C...)
will the versions for the different calcs compatible? (because there is a great discrepancy between the screens..)
Posted 20 December 2006 - 10:24 PM
I'm planning on making a MLC on-computer conversion program, which should take care of any incompatibilities. I don't know enough about Casio calculators though to make it convert to/from Casio calculators.
MLC 68K is in C, MLC TI-86 and MLC TI-83+ are in assembly.
MLC isn't just meant to be Multi-Platform; it is designed to be a much faster and more powerful gaming-specific programming language too.
Posted 21 December 2006 - 03:58 PM
Posted 21 December 2006 - 04:20 PM
I will see what I can do about a "compatibility mode" that allows their programs to be interpreted once I get detailed specs from their side, but I doubt that this will happen too soon
Posted 21 January 2007 - 03:24 AM
I'm working on some on-line documentation for MLC 68K that may interested you (http://bfr.tifreakware.net/mlcdoc). I'm also working on an on-computer conversion program that converts MLC programs from platform to platform, which will hopefully take care of any incompatibilities.
Posted 22 January 2007 - 12:37 PM
Posted 24 January 2007 - 06:47 PM
Posted 24 January 2007 - 07:38 PM
0 user(s) are reading this topic
0 members, 0 guests, 0 anonymous users


Off the Wall
I made an online order on December 3, 2016, I checked the order status. Guess what NO ORDER!!!! My credit card has been charged.......HELP!!!!!
Show us your personal collection!
- 2016 -
- 2015 -
- 2014 -
- 2013 -
- 2012 -
- 2011 -
- 2010 -
- 2009 -
Tag Archives: charity by design employee engagement
Guest Blogger: Kara Turenne, Alex and Ani Customer and Employee Engagement Manager, on National Volunteer Week
At Alex and Ani, we believe in giving back as much as we can. In celebration of National Volunteer Week, …
ALEX AND ANI


This software has enormous potential. To be fair it is still very early but the team is working to improve the product as well as provide support as needed. As long as they keep at it, it should be a home run. The design is really good and while the actual UX is going to need some work it's very customizable and built on a solid code base. Definitely, a product to "grow" with if you are building a listing directory.


Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.

Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.

In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.

Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!


Data Science 101: A career in the sexiest field of the 21st century
As labelled by some, the “sexiest field of the 21st century”, many of us still wonder what data scientists do and what is so sexy about it?
It is no surprise to us that modern businesses are now awash with data. More and more industries are realising the power of Big Data and searching for means through which businesses can leverage from it. The amazing ideas you see in Hollywood Sci-Fi movies, they can be turned into reality with the help of Data Science. This field is the face of Artificial Intelligence.
Currently, data volume has reached a whooping 44 trillion gigabytes. Sounds insane right? It really isn’t. Data Science uses scientific approaches, algorithms and systems to extract the knowledge from data and business can then leverage this data to make major decisions.
Let’s look into why Data Science is an upcoming field in the 21st century and give an overview of how it adds value to businesses as well as your personal life.
Why pursue a career in Data Science?
Traditionally, the data companies possessed was structured and small in size. This could be analyzed using simple Business Intelligence tools. However, nowadays, data is generated from different sources like financial logs, forms, sensors etc, which makes room for a lot of unstructured or semi-structured data. Currently 80% of the data acquired by organisations is unstructured which needs complex analytical tools and algorithms to process it.
This is not the only reason for this field to be so popular. Every recommendation you receive on E-commerce and Retail websites is because past data has been analyzed and the model has been trained to recommend products to you with precision.
Let’s look at weather forecasting as an example. Data from ships, airplanes, radars can be collected and analyzed to build models. These models will then not only help with weather forecasting but also predict any occurrence of natural calamities.
So what’s the problem currently faced by businesses? The shortage of Data Scientists is becoming a serious constraint in many sectors. From Government industries to Dating Apps, all are in dire need of help and expertise from professionals in the Data Science field to turn cutting-edge technology into actionable insights.
What is the role of a Data Scientist?
If you are looking to start your career as a Data Scientist, a basic understanding of programming languages and mathematics is required. A data scientist, also known as the “Master of Trial & Error” usually collects large amounts of structured as well as unstructured data from various sources. Furthermore, you will analyse and interpret it for various needs of the organisation. You will be creating statistical, network and big data methodologies for predictive fraud propensity models and use those models to create alerts.
You will be a huge help to the sales and marketing team, guiding them on understanding their audiences on a very granular level. Furthermore, you will play an important role in companies as you represent the voice of the customers through huge chunks of data.
How can Data Scientists add value to businesses?
- Empower management to make better decisions: A data scientist plays an important role in demonstrating the value of the company’s data to facilitate better decision-making processes. This process is enhanced by measuring and tracking the performance metrics of the organisation.
- Identify Opportunities: When discussing the organisation’s analytics system, data scientists question the existing processes and develop additional but better algorithms. As a data scientist, you are required to constantly improve the value that is derived from the organisation’s current data.
- Identify and Refine your Target Audience: All companies have one or more ways to collect customer data. If not used well, it will be a waste. The importance of data science is based on the ability to take existing data that is not necessarily useful on its own and generate insights. These insights will help businesses understand and relate better to their audience.
- Recruit the right talent for your organisation: Thanks to data science, recruiters’ lives have become much easier. With the amount of information available online through social media and corporate databases, a data scientist can work their way through all the data points and find the right fit for the organisation.
Data Science Professional Certification
Professional Certifications are a great way to gain an edge because they allow you to develop skills that are hard to acquire in the workplace. In this competitive world, professional certifications will also help in validating your skills, so recruiters and hiring managers know what they’re getting if they hire you.
With Certified Data Science Specialist Certification, you will learn how to leverage on data to unlock new economic value for your business, as well as apply useful data science concepts to every aspect of your daily life from personal finances to work decisions.
If you are pondering upon how to start your Data Science career, be sure to have some knowledge in Python Programming, R Programming and then secure your Data Science Certification! Once you have mastered that, you can either stop there or continue moving forward into Industrial Revolution 4.0 skills (Machine Learning, Artificial Intelligence, Internet of Things, Deep Learning).
Opportunities that come with a Data Science Certification
Good news for aspiring data scientists! With a professional certification in Data Science, you are not just restricted to becoming a Data Scientist. This field has opened doors to many different career options like Machine Learning Engineer, Machine Learning Scientist, Data Engineer, Business Intelligence Developer, Data Analyst & Statistician. Data Science is just a stepping stone to help build a solid base in order for you to excel in the above career fields if needed.
With several job opportunities out there available for you and several incentives by the government (click here to view the post), this is your time to make use of the opportunity and upskill or reskill yourself according to the current trends across industries. Stand out from the crowd and get noticed by employers to land your preferred jobs.


This variable sets up the command line shell for OS/2.
- OS/2 will not start without this variable
- /K C:\PROGRAM - Starts cmd.exe together with a program (program could be any executable program).
- /S - Disables CTRL+C. No interrupt for programs possible.
- /Q - NO ECHO
- /C PROGRAM - Starts a second command processor with a program. After execution of the program (e.g. DIR A:) return to the first command processor.
TIP: If you wish to run some other command line shell, such as 4OS2, change this line and the SET COMSPEC=C:\OS2\CMD.EXE line, substituting the appropriate EXE file for CMD.EXE.
Value can be any command shell with a full path.


Как известно, в теплую погоду многие жители крупных городов пользуются сервисами городского велопроката. Вот и Аркадий сегодня будет добираться от школы до дома, используя городские велосипеды.

Школа и дом находятся на одной прямой улице, кроме того, на той же улице есть n точек, где можно взять велосипед в прокат или сдать его. Первый велопрокат находится в точке x1 километров вдоль улицы, второй — в точке x2 и так далее, n-й велопрокат находится в точке xn. Школа Аркадия находится в точке x1 (то есть там же, где и первый велопрокат), а дом — в точке xn (то есть там же, где и n-й велопрокат). Известно, что xi < xi + 1 для всех 1 ≤ i < n.

Согласно правилам пользования велопроката, Аркадий может брать велосипед в прокат только на ограниченное время, после этого он должен обязательно вернуть его в одной из точек велопроката, однако, он тут же может взять новый велосипед, и отсчет времени пойдет заново. Аркадий может брать не более одного велосипеда в прокат одновременно. Если Аркадий решает взять велосипед в какой-то точке проката, то он сдаёт тот велосипед, на котором он до него доехал, берёт ровно один новый велосипед и продолжает на нём своё движение.

За отведенное время, независимо от выбранного велосипеда, Аркадий успевает проехать не больше k километров вдоль улицы.

Определите, сможет ли Аркадий доехать на велосипедах от школы до дома, и если да, то какое минимальное число раз ему необходимо будет взять велосипед в прокат, включая первый велосипед? Учтите, что Аркадий не намерен сегодня ходить пешком.


/********************************************************************
	created:	2015/03/12
	filename: 	GameFSM.h
	author:		Crazii

	purpose:	game finite state machine
*********************************************************************/
#ifndef __Blade_GameFSM_h__
#define __Blade_GameFSM_h__
#include <Factory.h>
#include <GameLibrary.h>

namespace Blade
{
	class BLADE_GAME_LIBRARY_API IGameState
	{
	public:
		//the initial state name of IGameState factory
		//users must register at least one subclass
		//and must register one sub class use this name
		static const TString INIT_STATE;
	public:
		virtual ~IGameState() {}

		/** @brief get the shown name of the state */
		virtual const TString& getName() const = 0;

		/** @brief  */
		virtual void	initialize() = 0;

		/** @brief  */
		virtual void	shutdown() = 0;

		/** @brief  */
		virtual void	run() = 0;

		/** @brief  */
		virtual void	update() = 0;

		/** @brief  */
		virtual void	syncUpdate() = 0;
	};//class IGameState

	extern template class BLADE_GAME_LIBRARY_API Factory<IGameState>;
	typedef Factory<IGameState> GameStateFactory;

	class BLADE_GAME_LIBRARY_API GameFSM : public Allocatable
	{
	public:
		GameFSM();
		~GameFSM();

		/** @brief  */
		void initialize(const TString& state);

		/** @brief  */
		void shutdown();

		/** @brief called on framework's run phase */
		void run();

		/** @brief called on framework's update phase */
		void update();

		/** @brief  */
		void syncUpdate();

		/** @brief  */
		void changeState(const TString& state);

		/** @brief  */
		inline IGameState* getCurrentState() const
		{
			return mCurState;
		}

	protected:
		IGameState*	mCurState;
	};//class GameFSM

}//namespace Blade

#endif // __Blade_GameFSM_h__


> Ususally the most important information is the first and last step
> The TopHat run should be called
> TopHat on SOLiD 24A
> The alignment stats should be
> SAM/BAM Summary Metrics of Solid 24A
> With the rest of the tools in the chain identified in the "more information"
> This would also give graph generating tools a fighting chance to present
> something useful in any graphs generated.
> GC Bias Plot of Solid 24A could have a title of Solid 24A instead of
> What do you think of this first-last model?
This model breaks down during experimentation. E.g. let's say three different
methods for trimming a FastQ dataset are tried before mapping with Bowtie.
Currently, the Bowtie runs are named differently b/c each trimmed dataset is a
unique input. Using first-last model, all datasets are named the same and it is
not possible to differentiate b/t them without looking at the inputs, which
requires clicking on the rerun/info button and finding the input(s). The
current approach used by Galaxy lists the inputs in the dataset title to avoid
Datasets with the same name becomes more problematic as more steps are added
b/t first and last because, while they have the same name, the steps taken to
produce them may be very different.
The first-last model could be nice for workflows, though, perhaps as an
extension of the "rename dataset" actions or a kind of global "rename dataset"
Please keep all replies on the list by using "reply all"
in your mail client. To manage your subscriptions to this
and other Galaxy lists, please use the interface at:


I prefer OpenCSV for CSV parsing in Java. That library also supports parsing of tab delimited files, here's how.
PHP function fputcsv() to export database to CSV
Animated GIF's have not been a very popular means in Email marketing probably because they... more »
For many web applications, slow performance can be as bad as no performance. Customers get... more »
React, by Facebook, is a very nice library for creating user interfaces. The only problem is... more »


Current version 0f Dooble (1.47) doesn't yet support some website especially the complex one. The websites that I tried so far are trello.com, whatbrowser.org.
whatbrowser.org doesn't recognize Dooble because Dooble doesn't advertise its presence in user agent strings.
Perhaps later versions of WebKit will provide more support.
This is not a bug. Dooble doesn't advertise itself.


Sep 04, 2008 01:47 AM|Benson Yu - MSFT|LINK
The “'System.Web.Extensions” is the Strong Named assembly that should be installed in GAC, the file not found issue should not caused by the relative path problem of the sub directory. In my opinion, the problem is the AJAX 1.0 extension is not installed
on the server.
To solve this issue, we can remove the “1.0.61025.0” version “System.Web.Extensions” assembly from the “assemblies” section. As you said, after doing that, the LINQ assembly not found issue appears. For this issue, I would recommend checking if .NET Framework
3.5 installed on the Server.


Currently the home page loads without the CSS files.
The code is in home.php and it uses
<?= $this->Html->css(['normalize.min', 'milligram.min', 'cake', 'home']) ?>
to access its css files.
My browser shows that, CakePHP is trying to find the file in “/pkm/css/normalize.min.css” (Project name is pkm).
Whereas, it should be trying to access “/pkm/webroot/css/normalize.min.css”.
I tried to retrace but that has been quite difficult,
Please be in mind that I’d like to keep the file in the webroot file if possible.
[“base”:protected]=> string(4) “/pkm” [“webroot”:protected]=> string(5) “/pkm/”
webroot folder is actually the top level folder on the web-page. So say you put that folder itself
hello.html with the text
Hello, then going to your website www.blah.com/hello.html will show that “Hello”. Also your .htaccess for the top-level of your webpage goes into webroot.
The root folder of the app is one level above the public www folder. Therefore your css, js & font etc folders go within the webroot one.
Thanks, I’m not sure if I understood you correctly but the CSS files were always in the webroot folder
I hope what I’m saying is correct, but your browser should be completely unaware of the name of your project - in that its a level above what the browser can see. So if its saying its trying to load the css from a folder that includes the path which has the name of your app then maybe the webroot folder isn’t configured correctly. In which case check your
define('WWW_ROOT', ROOT . DS . 'webroot' . DS); .
Otherwise bake a brand new test app and see if its pulling in milligram.min.css etc; and if so run WinMerge (or equivalent) to spot the differences in configurations.