SOCIO-ECONOMIC STATUS AND THE STRUCTURAL CHANGE OF DIETARY INTAKE IN HUNGARY: A PANNEL STUDY

Typically, big changes in the economic system lead to alterations on the disposable income of families and thus on their spending for different type of products, including food. These may imply, in the long run, a structural modification of the quality of diet of the population. After the fall of the socialist system, in the past two decades Central and Eastern European countries, including Hungary, went through a profound, and sometimes difficult transition of their political and economic systems, shifting from a centralized planned economy to an open market economy, and more importantly, the European Union integration. Economic change in lower-income and transitional economies of the world appears to coincide with increasing rapid social change. With respect to nutrition there is evidence that those countries are changing their diets and that these changes seem to be happening at a faster pace than ever before. In this paper we analyze the evolution of Hungarian dietary patterns based on socio-economic status (SES) data between 1993 and 2007. Data allows to define and profile several clusters based on aggregated consumption data, than to inspect the influence of SES variables using OLS and multinominal logit estimations.Transition economy, food consumption patterns, cluster analysis, logit analysis, Agricultural and Food Policy, Consumer/Household Economics, Demand and Price Analysis, Food Consumption/Nutrition/Food Safety, Food Security and Poverty, Health Economics and Policy,

NiMo syntax: part 1

Many formalisms for the specification for concurrent and distributed systems have emerged. In particular considering boxes and strings approaches. Examples are action calculi, rewriting logic and graph rewriting, bigraphs. The boxes and string metaphor is addressed with different levels of granularity. One of the approaches is to consider a process network as an hypergraph. Based in this general framework, we encode NiMo nets as a class of Annotated hypergraphs. This class is defined by giving the alphabet and the operations used to construct such programs. Therefore we treat only editing operations on labelled hypergraphs and afterwards how this editing operation affects the graph. Graph transformation (execution rules) is not covered here.Postprint (published version

Comparing MapReduce and pipeline implementations for counting triangles

A generalized method to define the Divide & Conquer paradigm in order to have processors acting on its own data and scheduled in a parallel fashion. MapReduce is a programming model that follows this paradigm, and allows for the definition of efficient solutions by both decomposing a problem into steps on subsets of the input data and combining the results of each step to produce final results. Albeit used for the implementation of a wide variety of computational problems, MapReduce performance can be negatively affected whenever the replication factor grows or the size of the input is larger than the resources available at each processor. In this paper we show an alternative approach to implement the Divide & Conquer paradigm, named pipeline. The main features of pipeline are illustrated on a parallel implementation of the well-known problem of counting triangles in a graph. This problem is especially interesting either when the input graph does not fit in memory or is dynamically generated. To evaluate the properties of pipeline, a dynamic pipeline of processes and an ad-hoc version of MapReduce are implemented in the language Go, exploiting its ability to deal with channels and spawned processes. An empirical evaluation is conducted on graphs of different sizes and densities. Observed results suggest that pipeline allows for the implementation of an efficient solution of the problem of counting triangles in a graph, particularly, in dense and large graphs, drastically reducing the execution time with respect to the MapReduce implementation.Peer ReviewedPostprint (published version

Dynamic Pipeline: an adaptive solution for big data

The Dynamic Pipelineis a concurrent programming pattern amenable to be parallelized. Furthermore, the number of processing units used in the parallelization is adjusted to the size of the problem, and each processing unit uses a reduced memory footprint. Contrary to other approaches, the Dynamic Pipeline can be seen as ageneralization of the (parallel) Divide and Conquer schema, where systems can be reconfigured depending on the particular instance of the problem to be solved. We claim that the Dynamic Pipelines is useful to deal with Big Data related problems. In particular, we have designed and implemented algorithms for computing graphs parameters as number of triangles, connected components, and maximal cliques, among others. Currently, we are focused on designing and implementing an efficient algorithm to evaluate conjunctive query.Peer ReviewedPostprint (author's final draft

Comparing MapReduce and pipeline implementations for counting triangles

A common method to define a parallel solution for a computational problem consists in finding a way to use the Divide and Conquer paradigm in order to have processors acting on its own data and scheduled in a parallel fashion. MapReduce is a programming model that follows this paradigm, and allows for the definition of efficient solutions by both decomposing a problem into steps on subsets of the input data and combining the results of each step to produce final results. Albeit used for the implementation of a wide variety of computational problems, MapReduce performance can be negatively affected whenever the replication factor grows or the size of the input is larger than the resources available at each processor. In this paper we show an alternative approach to implement the Divide and Conquer paradigm, named dynamic pipeline. The main features of dynamic pipelines are illustrated on a parallel implementation of the well-known problem of counting triangles in a graph. This problem is especially interesting either when the input graph does not fit in memory or is dynamically generated. To evaluate the properties of pipeline, a dynamic pipeline of processes and an ad-hoc version of MapReduce are implemented in the language Go, exploiting its ability to deal with channels and spawned processes. An empirical evaluation is conducted on graphs of different topologies, sizes, and densities. Observed results suggest that dynamic pipelines allows for an efficient implementation of the problem of counting triangles in a graph, particularly, in dense and large graphs, drastically reducing the execution time with respect to the MapReduce implementation.Peer ReviewedPostprint (published version

Human resources education in computing at Simón Bolívar University, Venezuela : 1972 to 1985

In this work we describe the efforts of the Computing Coordination at Simón Bolívar University, Venezuela, for forming Human Recourses in Computing at graduate and postgraduate levels in the years from 1972 to 1985. We also consider the background given by the Scientific Computer Program at the Calculus Institute, Buenos Aires University, that begun in 1962 and by the Computation Licentiate Program at Science Faculty, Venezuelan Central University, that begun in 1967. We close considering the impact that programs and professors from Simón Bolívar University have at national and regional levels.2nd IFIP Conference on the History of Computing and EducationRed de Universidades con Carreras en Informática (RedUNCI

Exploiting parallelism by customizing evaluation

NiMo is a totally graphic language from the family of Higher Order Typed languages with a strong Data flow inspiration. The interpreter is a specialized graph transformation system, and therefore the language operational semantics is given in terms of graph transformations. In NiMo parallelization is implicit and the evaluation policy is customizable following a process-centered approach. Here we explore some of the methodological possibilities that it opens. Some classical examples illustrate how combining modes greatly increases processor usage, decreases channel population, and achieves subnet synchronization in a very easy and intuitive way. We also present a stream programming technique and a real case application for generative and multistage-programming.Peer ReviewedPostprint (author’s final draft