投稿時間:2023-07-24 16:28:49 RSSフィード2023-07-24 16:00 分まとめ(37件)

カテゴリー等	サイト名等	記事タイトル・トレンドワード等	リンクURL	頻出ワード・要約等/検索ボリューム	登録日
IT	気になる、記になる…	Twitterの公式アカウントが｢X｣に ｰ 順次｢X｣に移行か	https://taisy0.com/2023/07/24/174400.html	twitter	2023-07-24 06:57:55
IT	ITmedia 総合記事一覧	[ITmedia PC USER] GIGABYTE、クランプ式アームを標準装備した28型4Kゲーミング液晶ディスプレイ	https://www.itmedia.co.jp/pcuser/articles/2307/24/news129.html	gigabytetechnology	2023-07-24 15:42:00
IT	ITmedia 総合記事一覧	[ITmedia Mobile] Twitterが「X」にブランド変更　新ロゴ披露、鳥のアイコンは消滅	https://www.itmedia.co.jp/mobile/articles/2307/24/news128.html	itmediamobiletwitter	2023-07-24 15:34:00
AWS	AWS Japan Blog	効果的なクラウドガバナンスによるクラウドのビジネス価値の向上	https://aws.amazon.com/jp/blogs/news/increase-business-value-from-the-cloud-with-effective-cloud-governance/		2023-07-24 06:15:52
python	Pythonタグが付けられた新着投稿 - Qiita	pythonライブラリEasyOCRをWindowsにインストールする	https://qiita.com/1_MCZ_1/items/3870714ebca9be8d9afe	文字コード	2023-07-24 15:31:39
js	JavaScriptタグが付けられた新着投稿 - Qiita	スプリント0	https://qiita.com/NK_KN/items/154cbec61fe090a8edb9	Detail Nothing	2023-07-24 15:01:35
Ruby	Rubyタグが付けられた新着投稿 - Qiita	アプリケーションを作成する手順	https://qiita.com/YokoYokoko/items/bd6e47125b2c2684098e	遷移	2023-07-24 15:45:07
Ruby	Rubyタグが付けられた新着投稿 - Qiita	enum	https://qiita.com/YokoYokoko/items/27b5ecc003252f14bf45	boolean	2023-07-24 15:41:02
Ruby	Rubyタグが付けられた新着投稿 - Qiita	BigDecimal型のデフォルト四捨五入を変更する方法	https://qiita.com/YokoYokoko/items/fa4e4780cb326badfbde	modebigdecimalrounddown	2023-07-24 15:26:27
AWS	AWSタグが付けられた新着投稿 - Qiita	スプリント0	https://qiita.com/NK_KN/items/154cbec61fe090a8edb9	Detail Nothing	2023-07-24 15:01:35
Ruby	Railsタグが付けられた新着投稿 - Qiita	BigDecimal型のデフォルト四捨五入を変更する方法	https://qiita.com/YokoYokoko/items/fa4e4780cb326badfbde	modebigdecimalrounddown	2023-07-24 15:26:27
技術ブログ	Developers.IO	売上上げたいならmixpanelをこう使え！#devio2023	https://dev.classmethod.jp/articles/mixpanel-devio2023/	developersio	2023-07-24 06:22:27
海外TECH	DEV Community	Part 2. Application Core Design	https://dev.to/bespoyasov/part-2-application-core-design-1l6i	Part Application Core Design️Originally published at bespoyasov me Subscribe to my blog to read posts like this earlier Let s continue the series of posts and experiments about explicit software design Last time we discussed what a domain model is its benefits and how we can use functional programming static typing and DDD to simplify modeling In this post we will talk about how to design use cases and discuss how to integrate our application with the outside world without the need to rewrite a lot of code By the way source code for this series is available on GitHub Give the repo a star if you like the posts Data and Use CasesOur domain model contains data transformations that occur inside the converter but does not describe how the application should interact with the user To describe such interaction we will create use cases Simply put use cases are descriptions of what should happen when a user interacts with the application They show what data the application will receive how and where from what domain function it will execute afterwards and how it will present the result of the work to the user on the screen or in the CLI We can create such a use case for example for updating quotes and get something like Use Case “Refresh Exchange Rates When the user clicks a refresh button The app gets fresh exchange rates from the API Finds currently entered base currency value Recalculates the quote value based on these inputs Shows the updated values on the screen Note that while we describe the details of interaction with the API for obtaining exchange rates we do not specify concrete functions for updating the UI Right now we are only outlining the sequence of actions describing operations “at a high level Levels of AbstractionWhen I mention “design levels I like to refer to Mark Seemann s post on “Fractal Architecture In this concept Mark presents programs as a set of nested hexagons Each hexagon contains a limited number of components but they can be zoomed in to see details Thus we keep a limited amount of information at each level not overloading our heads I also like to use this metaphor when designing an app Each level of a use case is like a hexagon At first we see only a “general description of the operations that the application will perform Later when we move on to implementation we will “zoom in to lower levels and work out each operation separately in more detail and depth Use Case as TypesCarefully examining the described scenario we can notice that some of its operations can already be represented as types of the domain model Use Case “Refresh Exchange Rates When the user clicks a refresh button The app gets fresh ExchangeRates from the API Finds currently entered BaseValue Recalculates the QuoteValue based on these inputs Shows the updated values on the screen If we take this further we can represent the entire use case as a sequence of data transformations from the user input signal to displaying information on the screen ButtonClickEvent gt ExchangeRates gt BaseValue QuoteCode gt QuoteValue ExchangeRate gt DataRenderedEventWe will now try to express this sequence in the function code below Impureim SandwichIn the use case above you may notice that interactions with the outside world ButtonClickEvent and DataRenderedEvent are located at the beginning and end of the use case while only domain data transformations are in the middle This code organization is called “Functional core in an imperative shell or “Impureim sandwich Its essence is to concentrate all “impure code at the edges and keep only data transformations built on pure functions inside The main benefit of the sandwich is that it removes the influence of unpredictable effects on the data we work with However in our use case there are a few more benefits Since the “entry into the domain is explicit it is more convenient for us to validate the input data and check the invariants The entire use case logic is reproducible and easily testable because it only depends on the input data We don t need to pre plan how to interact with the outside world but we ll talk more about this a little later Designing the Use CaseWhen designing use cases we can use the same approach we used when developing the model last time First we describe the functionality in types and then we implement it as a function Let s go through all the stages of the use case and turn them into types Clicking on the button initiates the use case after which we need to get exchange rates from the server read the current value of the base currency and the code of the quote currency We can express these two operations as follows Get fresh exchange rates from the API or a runtime data storage type FetchRates gt Promise lt ExchangeRates gt type ReadConverter gt BaseValue QuoteCurrencyCode Then we pass the available data through the existing domain transformations Transform data using the domain model type LookupRate rates ExchangeRates code QuoteCode gt ExchangeRate type CalculateQuote base BaseValue rate ExchangeRate gt QuoteValue Finally we display the result on the screen Update the data in the UI type UpdateConverter rates ExchangeRates quote QuoteValue gt void Power of AbstractionThe described actions are easily held in our heads as a sequence because the type names are expressed in terms suitable for this level of abstraction They do not delve too much into the details of each operation but express its intent Type names “package all the complexity and details of each action leaving only the most important information visible This approach helps us to dive into the code gradually receiving information about the system in a controlled way without overwhelming our working memory In addition separating intention from implementation helps us to design use cases without thinking about the tools we will use Instead we roughly describe the functionality we want to obtain from the tools in the types This approach allows us to delay making big decisions about which libraries or third party tools to use The advantage is that we may not yet know all the actual requirements of the application and it may be too early to choose tools By abstracting away the tooling for now we give ourselves a better chance to select the right tools in the future when we have a better understanding of how the application will work Delaying tooling decisions is not always necessary It is quite possible that we already know that we will be using a particular lib or the database we will use on the backend and it is likely that this tool will not change In that case there is not much sense in “abstracting this dependency Application PortsThe types that “abstract out libraries and third party services are the so called application ports A port is a specification of how an application wants to communicate with the outside world how it wants to adapt the world to its needs Ports describe how and in what form the application is ready to receive data and what result it will provide to the outside world The ports through which the outside world addresses the application are called input ports And those through which the application talks to the outside world are called output ports The first ones describe what needs to be done to “push the application do some work while the second ones describe how the app will “initiate the contact itself and what additional functionality it may need For example in the case of updating exchange rates the output port to the application would be some button click handler function This type says “When the user clicks the button the application will start an asynchronous process type RefreshRates gt Promise lt void gt The output ports would be the types describing the server and data storage that would keep the previously loaded data Network amp API type FetchRates gt Promise lt ExchangeRates gt Runtime storage type ReadConverter gt ConverterModel type UpdateConverter patch Partial lt ConverterModel gt gt void We can think of these types as the “levers and “slots that the “application box provides to the outside All interaction with the outside world will go through them Clear application boundaries and rules for communicating with it abstracts the details of the infrastructure and UI A “buffer zone appears between the application and third party modules which helps limit the propagation of changes from the application to the outside world and vice versa We ll need adapters and anti corruption layer to create such a “buffer zone but let s not get ahead of ourselves We ll talk about all these concepts in detail in the next posts Abstraction Driven ImplementationLike last time having described the functionality in types we can proceed with the implementation of the use case as a function core refreshRatesexport const refreshRates gt Calling this function is the entry point into the application core from the UI This means that this function implements the input port Let s make sure it implements the RefreshRates type core ports inputexport type RefreshRates gt Promise lt void gt core refreshRatesexport const refreshRates RefreshRates async gt The function must be asynchronous because RefreshRates returns a promise To ensure the function implements some type we can explicitly specify its type with Then if the types don t match TypeScript will complain about it The contents of the refreshRates function will be a description of the entire use case core refreshRatesimport type RefreshRates from ports input import calculateQuote from domain calculateQuote import lookupRate from domain lookupRate export const refreshRates RefreshRates async gt Fetch latest rates from the API const rates await fetchRates Get the current model from runtime storage const model readConverter Run all the domain data transformations const rate lookupRate rates model quoteCode const quote calculateQuote model baseValue rate Update the runtime storage consequently triggering the rerender saveConverter rates quoteValue quote If we were working not with React but with a lib that doesn t automatically track rerenders we could trigger the rerender from here manually Inside the use case we rely on guarantees from the functions that implement the output ports fetchRates readConverter and saveConverter Thanks to the types we know what arguments each of them expects and what result we will get after the call core pots outputtype FetchRates gt Promise lt ExchangeRates gt type ReadConverter gt Converter type SaveConverter patch Partial lt Converter gt gt void We can replace the implementations of these functions with stubs for the first time so that the compiler does not complain about missing variables const fetchRates FetchRates async gt const readConverter ReadConverter gt const saveConverter SaveConverter gt Use Case DependenciesThe stub functions for the output ports help with the initial design but that s where their usefulness ends We can use type reliance more extensively Imagine instead of separate functions we have an object in which all these functions are gathered together core refreshRatestype AllOutputPorts fetchRates FetchRates readConverter ReadConverter saveConverter SaveConverter const ports AllOutputPorts We don t care exactly how the functions get into this object yet so let s just assume that they somehow end up there Then we can refer to this object and get all the functions we need from it in the use case code core refreshRatesexport const refreshRates RefreshRates async gt const fetchRates readConverter saveConverter ports Use case code If we go a little further we notice that we don t have to keep the dependency object inside the function We can pass it as an argument to refreshRates core refreshRatesexport const refreshRates RefreshRates async fetchRates readConverter saveConverter AllOutputPorts gt The ports are now in a closure of the refreshRates function not in any particular object This means that for refreshRates they are very real but we don t need to create stubs for the ports anymore All dependencies of the refreshRates function are taken directly from its arguments However we broke the guarantees of the RefreshRates type According to this type the refreshRates function should not require arguments and now it needs an object with dependencies Let s fix this by adding a default value to the argument so it s no longer required And update the type name as well core refreshRatesconst stub as Dependencies export const refreshRates RefreshRates async fetchRates readConverter saveConverter Dependencies stub gt If you recognize in this Dependency Injection DI that s pretty much it More precisely its near functional counterpart Generally speaking there are several techniques for dependency management in the near functional paradigm and we haven t chosen the best one yet We ll see how to use more elegant techniques in the future but for now we ll go with that one By the way in pure functional programming there is no concept of dependencies in principle there all program operation is based on the Impureim Sandwich principle On GitHub I put a separate example of how the use case could be implemented “more functionally Also we ll mention real DI containers in some of the future posts but we won t use them or focus our attention on them too much because in FP like world the dependency management is explicit If you re interested in how to use such containers in more OOP like way I can recommend reading this post However it doesn t mean that we can t combine “near functional style with DI containers It s just a matter of taste and tools we use Testing Use Case“Dependency Injection gives us the opportunity to test a use case without waiting for its dependencies to be ready This is liberating because we can distribute work for example between different teams or switch between tasks depending on priorities Obviously we cannot write integration tests without real dependencies but we can write unit tests For example let s describe tests for the use case with exchange rates update Let s start with planning the tests with todo core refreshRates testdescribe when called gt it todo should recalculate the quote value using the rates from the API it todo should update the exchange rates data with the one from the API it todo We will try to use output based to test the use case that is to simulate the input and monitor the output of the function Sometimes we will also use state based testing although it is less resistant to change I recommend reading “Principles and methods of unit testing by Vladimir Khorikov In the book you can read more about unit testing its principles and difference between output based and state based tests To test the use case we replace dependencies with stubs and mocks We replace the functions that provide us some data with stubs that don t contain complex functionality To check the result we will use a spyーa function that will monitor how and with what arguments it will be called core refreshRates test Simple stubs provide input data const fetchRates async gt rates const readConverter gt converter Spy checks the output calls const saveConverter vi fn All the dependencies for the use case const dependencies fetchRates readConverter saveConverter Then we ll describe that as a result of the work the spy should be called with certain data core refreshRates testdescribe when called gt it should recalculate the quote value using the rates from the API async gt As the result of the use case await refreshRates dependencies The spy must be called with this data expect saveConverter toHaveBeenCalledWith quoteValue rates Since dependency types can be implemented by anything it s pretty easy to replace them with a stub or a mock This way we can test the use case function based on contracts I usually try to write my tests and functions so that my code contains as few mocks as possible and as many stubs as possible This helps avoiding test induced damage and also makes tests independent of the specific implementation of dependencies and the location of modules in the file system But this is just my preference your tastes in testing might differ Default Dependencies and CompositionWe mentioned above that passing dependencies as the last argument is not the best solution The argument with dependencies even if optional still violates the function interface We would like the function type to be unambiguous and forbid any invalid call Dependencies get into a function in runtime and since the argument is implicit it s easy to miss and forget to pass it We would like all the “function preparations to happen beforehand and if there are no dependencies the code won t get built at all In a future post we ll see how to achieve all of this by partially applying functions and “baking dependencies Intention and ImplementationIf we look at the imports in the use case file we see that the application core uses only domain functions and types of input and output ports core refreshRates ts From ports import only types import type RefreshRates from ports input import type FetchRates ReadConverter SaveConverter from ports output From domain import functions import calculateQuote from domain calculateQuote import lookupRate from domain lookupRate The use case sort of abstracts away from specific implementations of the application ports allowing them to be passed from the outside Intention Composition Implementation RefreshRates RefreshRates FetchRates fetchRatesFn lt const fetchRatesFn async gt ReadConverter gt readConverterFn lt const readConverterFn gt SaveConverter saveConverterFn lt const saveConverterFn data gt Declares dependencies Configure work of the functionthat can be configurable by passing specific dependencies So the it becomes unimportant for the application core how exactly the ports to the outside world are implemented as long as their interface is respected We sort of break down the work of the use case into intention and implementation We express intention in types and code that relies on them And we express the implementation in code that substitutes specific dependenciesーcomposition By doing so we separate code with functionality from service code that “glues different modules together By the way we also can forbid use cases to import port implementations by using linter I wouldn t do it by default but it wouldn t be hard to set up such a rule if necessary Dependency DirectionThe separation of functionality and composition helps the application core not to depend on third party code infrastructure UI networking On the contrary the application requires the outside world to “adjust to its needs and depend on domain code and use cases This dependency direction for example makes it easier to replace tools in testing In tests we just replace the real service with a mock or stub core refreshRates testconst saveConverter vi fn const dependencies saveConverter describe when called gt it should recalculate the quote value using the rates from the API async gt await refreshRates dependencies expect saveConverter toHaveBeenCalledWith This is a rather subjective argument because services can always be mocked at module level Although it is also worth considering that module level mocks can be more difficult to update and they bind us to the file structure What to choose depends on the problem Full independence from the tools is not always necessary and justified and in general it sounds utopian and maximalist Sometimes it is much more effective to be bound to some library or service especially if we are not going to change it But since we re experimenting and writing code “by the book we ll close our eyes to that for now Other Use CasesIn addition to updating exchange rates we have two more use cases updating the value of the base currency and changing the quote currency Let s implement them as well let s start with the first one First let s declare the input port core ports inputexport type UpdateBaseValue value string number gt void The function will accept a string or a number which we will try to normalize to a base currency value We commit to doing the normalization ourselves to ensure consistency of the data because right now only the domain knows how to detect a valid value We also free the module that will run this use case from having to worry about the value being passed Then we design the use case itself core updateBaseValueexport const updateBaseValue UpdateBaseValue rawValue gt Impure section Get current quoteCode and rates Pure section Normalize the value received as an argument Determine the current rate of the selected pair Recalculate the quote currency value Impure section Save updated value of base currency Save the recalculated quote currency value The pure section we can already build from domain functions core updateBaseValueexport const updateBaseValue UpdateBaseValue rawValue gt Impure section Get current quoteCode and rates const baseValue createBaseValue rawValue const currentRate lookupRate model rates model quoteCode const quoteValue calculateQuote baseValue currentRate Impure section Save updated value of base currency Save the recalculated quote currency value And in order to retrieve and store the data we will connect to the output ports core updateBaseValue Declare required dependencies type Dependencies readConverter ReadConverter saveConverter SaveConverter export const updateBaseValue UpdateBaseValue rawValue Get the dependencies inside the function readConverter saveConverter Dependencies gt const model readConverter saveConverter baseValue quoteValue And like last time to avoid breaking the UpdateBaseValue type let s add a stub with the default value of the argument core updateBaseValueconst stub as Dependencies export const updateBaseValue UpdateBaseValue rawValue readConverter saveConverter Dependencies stub gt Now we can write tests for this function by composing the use case with stubs and mocks core updateBaseValue testconst readConverter gt converter const saveConverter vi fn const dependencies readConverter saveConverter describe when given a valid base value update gt it recalculates the model according to the new value and current rates gt updateBaseValue dependencies expect saveConverter toHaveBeenCalledWith baseValue quoteValue describe when given an invalid base value update gt it recalculates the quote using as the base value gt updateBaseValue invalid dependencies expect saveConverter toHaveBeenCalledWith baseValue quoteValue Test Driven DevelopmentAs in the case of the domain we can use TDD as a design tool for use cases Given that we rely on abstractions we can describe our expectations without having to write real implementations of dependencies Again my goal is not to “sell TDD This series is an experiment where we try different approaches and look at their applicability to understand the pros and cons of the techniques used Whether to apply a particular tool paradigm or methodology depends on the specific task at hand Let s write the last remaining case with a change of quote currency using TDD Let s plan out the desired behavior core changeQuoteCode testdescribe when given a new quote code gt it todo changes the quote code in the model it todo recalculates quote according to the new code and current rates Let s write a call to the first function and declare in which form we want to get the result core changeQuoteCode testconst saveConverter vi fn const dependencies saveConverter describe when given a new quote code gt it changes the quote code in the model gt After the function call changeQuoteCode DRG dependencies We expect to see the change of quote currency in the model expect saveConverter toHaveBeenCalledOnce expect saveConverter mock lastCall at quoteCode toBe DRG Then we create an empty implementation and check that the test fails for the expected reason AssertionError expected spy to be called once it changes the quote code in the model gt changeQuoteCode DRG dependencies expect saveConverter toHaveBeenCalledOnce expect saveConverter mock lastCall at quoteCode toBe DRG Expected Received This time we won t get into details of TDD and its principles But if you re interested in learning about it I ll leave some links to materials about it Then we implement the function core changeQuoteCodetype Dependencies saveConverter SaveConverter export const changeQuoteCode ChangeQuoteCode quoteCode saveConverter Dependencies gt saveConverter quoteCode Then we will write the second test This time we need to mix in some state and data so we create another stub in the dependencies core changeQuoteCode testconst readConverter gt converter const saveConverter vi fn const dependencies readConverter saveConverter it recalculates quote according to the new code and current rates gt changeQuoteCode DRG dependencies expect saveConverter toHaveBeenCalledOnce expect saveConverter mock lastCall at quoteValue toBe After that we check that the test fails because there is no value and create an implementation core changeQuoteCodetype Dependencies readConverter ReadConverter saveConverter SaveConverter export const changeQuoteCode ChangeQuoteCode quoteCode readConverter saveConverter Dependencies gt const model readConverter const currentRate lookupRate model rates quoteCode const quoteValue calculateQuote model baseValue currentRate saveConverter quoteCode quoteValue Finally let s fix the broken ChangeQuoteCode input port interface and add a stub for dependencies const stub as Dependencies export const changeQuoteCode ChangeQuoteCode quoteCode readConverter saveConverter Dependencies stub gt Next TimeIn this post we designed use cases and discussed how to connect our app with the outside world without depending on third party services Next time we ll talk about how to implement application ports what the difference is between UI and infrastructure from an application core s perspective and what to do if the outside world doesn t work the way the application wants it to Sources and ReferencesLinks to books articles and other materials I mentioned in this post Source code for the current step on GitHub BooksClean Architecture by Robert C MartinCode That Fits in Your Head by Mark SeemannDependency Injection in NET by Mark SeemannUnit Testing Principles Practices and Patterns by Vladimir Khorikov Dependency ManagementDependency injection WikipediaDependency Injection in NET by Mark SeemannDependency Injection with TypeScript in PracticeDependency inversion principle WikipediaSix approaches to dependency injection Testing Mocks and StubsLet s speak the same languageMocking in VitestMocks for Commands Stubs for QueriesTDD What How and WhyTest induced design damage Abstraction Composition and effectsAbstraction as a design toolFractal hex flowersFunctional architecture is Ports and AdaptersImpureim sandwichPorts amp Adapters Architecture Other ConceptsAnti corruption layerClosures in JSRobustness principle	2023-07-24 06:29:34
海外TECH	DEV Community	What is SGPA?	https://dev.to/oliviasmit12427/what-is-sgpa-4dlj	What is SGPA SGPA Calculator it is a numerical representation of a student s academic performance for a specific semester or academic term SGPA is a part of the broader GPA Grade Point Average system used by educational institutions to assess students overall academic achievements In a typical educational setting students complete multiple courses in a semester each with its own credit value and grading scale The SGPA is calculated by assigning each completed course a grade point based on the earned letter grade and then taking the average of these grade points The scale for SGPA often ranges from to or a similar range depending on the institution The higher the SGPA the better the academic performance for that particular semester Conversely a lower SGPA may indicate that a student s performance needs improvement in the courses they have taken during that semester SGPA is an important metric as it helps institutions and students track their academic progress on a semester by semester basis It also plays a role in determining academic standing eligibility for certain programs or scholarships and overall academic achievements	2023-07-24 06:00:44
金融	JPX マーケットニュース	[東証]「会計基準の選択に関する基本的な考え方」の開示内容の分析について≪2023年3月期決算会社まで≫	https://www.jpx.co.jp/news/1020/20230724-01.html	会計基準	2023-07-24 15:30:00
海外ニュース	Japan Times latest articles	Lawmaker on crusade against South Korea’s ‘no-kid zones’	https://www.japantimes.co.jp/news/2023/07/24/asia-pacific/south-korea-no-kids-zone-lawmaker-crusade/	Lawmaker on crusade against South Korea s no kid zones Seoul spends billions to encourage citizens to have more babies offering subsidies babysitting services and infertility treatment but fertility rates continue to drop	2023-07-24 15:10:17
ニュース	BBC News - Home	Rhodes fires: Planes sent to collect stranded Britons	https://www.bbc.co.uk/news/uk-66286741?at_medium=RSS&at_campaign=KARANGA	british	2023-07-24 06:40:30
ニュース	BBC News - Home	Russia accuses Ukraine of Moscow drone attack	https://www.bbc.co.uk/news/world-europe-66286102?at_medium=RSS&at_campaign=KARANGA	ukraine	2023-07-24 06:48:06
ニュース	BBC News - Home	Ukraine war: Russia hits Odesa after killing grain deal	https://www.bbc.co.uk/news/world-europe-66272001?at_medium=RSS&at_campaign=KARANGA	odesa	2023-07-24 06:14:37
ニュース	BBC News - Home	Former West Ham goalkeeper Hislop 'conscious' after on-air collapse	https://www.bbc.co.uk/sport/football/66287304?at_medium=RSS&at_campaign=KARANGA	california	2023-07-24 06:10:29
ニュース	BBC News - Home	Real Madrid: Jude Bellingham makes debut in 3-2 win over AC Milan in Los Angeles	https://www.bbc.co.uk/sport/football/66287068?at_medium=RSS&at_campaign=KARANGA	Real Madrid Jude Bellingham makes debut in win over AC Milan in Los AngelesReal Madrid manager Carlo Ancelotti praises the fantastic Jude Bellingham after he makes his debut in a friendly win over AC Milan	2023-07-24 06:21:55
ニュース	BBC News - Home	Israel judicial reform: Netanyahu leaves hospital ahead of key vote	https://www.bbc.co.uk/news/world-middle-east-66281968?at_medium=RSS&at_campaign=KARANGA	hospital	2023-07-24 06:06:22
ニュース	BBC News - Home	Elon Musk: Time to say goodbye to Twitter bird logo	https://www.bbc.co.uk/news/business-66284304?at_medium=RSS&at_campaign=KARANGA	larry	2023-07-24 06:03:28
ニュース	BBC News - Home	The Ashes 2023: Australia need to use some Bazball tactics to win series - Glenn McGrath	https://www.bbc.co.uk/sport/cricket/66282987?at_medium=RSS&at_campaign=KARANGA	The Ashes Australia need to use some Bazball tactics to win series Glenn McGrathAustralia have done their first job by retaining the Ashes now they must copy England s tactics to win the urn outright writes Glenn McGrath	2023-07-24 06:15:46
マーケティング	MarkeZine	2023年10月1日、ステルスマーケティングに関する規制法が施行！マーケターがとるべき対策は【無料】	http://markezine.jp/article/detail/42867	規制	2023-07-24 15:15:00
IT	週刊アスキー	さよならTwitterの青い鳥。11年使われたアイコン、デザイナーが解説	https://weekly.ascii.jp/elem/000/004/146/4146482/	twitter	2023-07-24 15:45:00
IT	週刊アスキー	PC-88版『ヴァリス』など5タイトルを収録する『夢幻戦士ヴァリスCOLLECTION3』がSwitchに登場！	https://weekly.ascii.jp/elem/000/004/146/4146506/	collection	2023-07-24 15:45:00
IT	週刊アスキー	ギア5のルフィが参戦！『ONE PIECE 海賊無双4』追加DLC第4弾～第6弾が発表	https://weekly.ascii.jp/elem/000/004/146/4146503/	onepiece	2023-07-24 15:40:00
IT	週刊アスキー	パナソニック、手のひらサイズの5枚刃シェーバー「ラムダッシュ パームイン」発表	https://weekly.ascii.jp/elem/000/004/146/4146484/	espva	2023-07-24 15:30:00
IT	週刊アスキー	サンワサプライ、水平・垂直方向にコネクターが曲がり回転するHDMIケーブルとHDMI延長ケーブルを発売	https://weekly.ascii.jp/elem/000/004/146/4146497/	kmhddenn	2023-07-24 15:30:00
IT	週刊アスキー	おひとり向け「マイドミノ」破格の699円～ 平日のランチに！	https://weekly.ascii.jp/elem/000/004/146/4146467/	達成	2023-07-24 15:05:00
IT	週刊アスキー	お寿司20貫 1080円の【超】得にぎりフェアが復活！小僧寿しで本日より	https://weekly.ascii.jp/elem/000/004/146/4146473/	小僧寿し	2023-07-24 15:25:00
IT	週刊アスキー	ほっかほっか亭「うな重」「うなぎW重」丑の日に向けて予約も受付中	https://weekly.ascii.jp/elem/000/004/146/4146518/	土用の丑の日	2023-07-24 15:50:00
マーケティング	AdverTimes	38年のギャラリー活動に幕、リクルート「G8」8月から最後の展覧会	https://www.advertimes.com/20230724/article427991/	theending	2023-07-24 06:46:14
マーケティング	AdverTimes	内定承諾率を高めるオウンドメディアの運用方法とは	https://www.advertimes.com/20230724/article427955/	bravegroup	2023-07-24 06:40:03
マーケティング	AdverTimes	店頭で見ない日はない「オクチシリーズ」 ヒットの裏側	https://www.advertimes.com/20230724/article427974/	裏側	2023-07-24 06:19:44
マーケティング	AdverTimes	カーシェア、タクシー配車、シェアサイクル認知率約5割、モビリティサービス調査	https://www.advertimes.com/20230724/article427916/	利用実態	2023-07-24 06:19:19